Added clang 7 CI job.

Use https in URLs in readme.
Corrected a typo in readme.
2026-01-20 16:42:14 +00:00 · 2018-11-01 20:24:04 +03:00 · 2018-11-01 16:33:47 +03:00 · 2018-11-01 16:25:15 +03:00 · 2018-11-01 16:14:20 +03:00 · 2018-10-30 11:46:15 +03:00
44 changed files with 2111 additions and 4490 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -0,0 +1,224 @@
+# Copyright 2016, 2017 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+language: cpp
+
+sudo: false
+
+python: "2.7"
+
+os:
+  - linux
+  - osx
+
+branches:
+  only:
+    - master
+    - develop
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-8
+      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
+
+    - os: linux
+      compiler: clang++-libc++
+      env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - libc++-dev
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.5
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.5
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.6
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.8
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-3.9
+
+    - os: linux
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
+
+    - os: linux
+      compiler: clang++-5.0
+      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-5.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+
+    - os: linux
+      compiler: clang++-6.0
+      env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - clang-6.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-6.0
+
+    - os: linux
+      compiler: clang++-7
+      env: TOOLSET=clang COMPILER=clang++-7 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - clang-7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-7
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
+
+install:
+  - cd ..
+  - git clone -b $TRAVIS_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule update --init tools/boostdep
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - cp -r $TRAVIS_BUILD_DIR/* libs/integer
+  - python tools/boostdep/depinst/depinst.py integer
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - |-
+    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+  - ./b2 -j3 libs/integer/test toolset=$TOOLSET cxxstd=$CXXSTD
+
+notifications:
+  email:
+    on_success: always
--- a/README.md
+++ b/README.md
@@ -0,0 +1,30 @@
+# Boost.Integer
+
+Boost.Integer, part of collection of the [Boost C++ Libraries](https://github.com/boostorg), 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.
+
+### Directories
+
+* **doc** - QuickBook documentation sources
+* **include** - Interface headers of Boost.Integer
+* **test** - Boost.Integer unit tests
+
+### More information
+
+* [Documentation](https://boost.org/libs/integer)
+* [Report bugs](https://github.com/boostorg/integer/issues/new). Be sure to mention Boost version, platform and compiler you're using. A small compilable code sample to reproduce the problem is always good as well.
+* Submit your patches as pull requests against **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](https://www.boost.org/LICENSE_1_0.txt).
+
+### Build status
+
+Master: [![AppVeyor](https://ci.appveyor.com/api/projects/status/iugyf5rf51n99g3w?svg=true)](https://ci.appveyor.com/project/Lastique/integer/branch/master) [![Travis CI](https://travis-ci.org/boostorg/integer.svg?branch=master)](https://travis-ci.org/boostorg/integer)
+Develop: [![AppVeyor](https://ci.appveyor.com/api/projects/status/iugyf5rf51n99g3w/branch/develop?svg=true)](https://ci.appveyor.com/project/Lastique/integer/branch/develop) [![Travis CI](https://travis-ci.org/boostorg/integer.svg?branch=develop)](https://travis-ci.org/boostorg/integer)
+
+### License
+
+Distributed under the [Boost Software License, Version 1.0](https://www.boost.org/LICENSE_1_0.txt).
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -0,0 +1,62 @@
+# Copyright 2016 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+  only:
+    - master
+    - develop
+
+platform:
+  - x64
+
+environment:
+  matrix:
+    - ARGS: --toolset=msvc-9.0  address-model=32
+    - ARGS: --toolset=msvc-10.0 address-model=32
+    - ARGS: --toolset=msvc-11.0 address-model=32
+    - ARGS: --toolset=msvc-12.0 address-model=32
+    - ARGS: --toolset=msvc-14.0 address-model=32
+    - ARGS: --toolset=msvc-12.0 address-model=64
+    - ARGS: --toolset=msvc-14.0 address-model=64
+    - ARGS: --toolset=msvc-14.0 address-model=64 cxxflags=-std:c++latest
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      ARGS: --toolset=msvc-14.1 address-model=64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      ARGS: --toolset=msvc-14.1 address-model=32
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      ARGS: --toolset=msvc-14.1 address-model=64 cxxflags=-std:c++latest
+    - ARGS: --toolset=gcc address-model=64
+      PATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;%PATH%
+    - ARGS: --toolset=gcc address-model=64 cxxflags=-std=gnu++1z
+      PATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;%PATH%
+    - ARGS: --toolset=gcc address-model=32
+      PATH: C:\mingw-w64\i686-5.3.0-posix-dwarf-rt_v4-rev0\mingw32\bin;%PATH%
+    - ARGS: --toolset=gcc address-model=32 linkflags=-Wl,-allow-multiple-definition
+      PATH: C:\MinGW\bin;%PATH%
+
+
+install:
+  - cd ..
+  - git clone -b %APPVEYOR_REPO_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule update --init tools/boostdep
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\integer
+  - python tools/boostdep/depinst/depinst.py integer
+  - bootstrap
+  - b2 headers
+
+build: off
+
+test_script:
+  - cd libs\config\test
+  - ..\..\..\b2 config_info_travis_install %ARGS%
+  - config_info_travis
+  - cd ..\..\integer\test
+  - ..\..\..\b2 -j3 %ARGS% define=CI_SUPPRESS_KNOWN_ISSUES
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@@ -1,88 +1,12 @@
-# jamfile to build Boost.Integer Documentation.
+

 # 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)

-# Revised to include Doxygen and Autoindex, and code snippets from examples.
-# Copyright Paul A. Bristow 2015
-
-using boostbook ;
-using doxygen ;  # Required if you want to use Doxygen.
 using quickbook ;
-using auto-index ;
-
-path-constant here : . ; # convenient to refer to files in the same directory as this jamfile.v2
-path-constant parent : .. ;  # Parent directory, /libs/integer/
-
-if --enable-index in  [ modules.peek : ARGV ]
-{
-   ECHO "Building the Integer docs with automatic index generation enabled." ;
-   using auto-index ;
-   project integer_doc : requirements
-             <auto-index>on
-             <auto-index-script>integer.idx
-             <auto-index-prefix>.
-             <auto-index-verbose>on
-             <format>html:<auto-index-internal>on
-             <format>html:<xsl:param>generate.index=0
-             <format>pdf:<auto-index-internal>on
-             <format>pdf:<xsl:param>index.on.type=1
-             <quickbook-define>enable_index ;
-}
-else
-{
-   project integer_doc ;
-   ECHO "Building the Integer docs with automatic index generation disabled. Try building with --enable-index." ;
-}
-
-
-xml integer
-   :
-    integer.qbk # This is 'root' Quickbook file (that may include other .qbk files).
-   ;
-
-doxygen autodoc
-  :
-    [ glob $(here)/../include/boost/*.hpp ]
-    [ glob $(here)/../include/boost/integer/*.hpp ]
-    # but could also include this and switch Boost.Integer C++ reference info to include implementation details (or not) using Doxygen macro DETAIL.
-    # See http://www.stack.nl/~dimitri/doxygen/manual/commands.html#cmdcond
-    # and http://www.stack.nl/~dimitri/doxygen/manual/config.html#cfg_enabled_sections
-    # by adding this line below with other Doxygen parameters
-    #     <doxygen:param>ENABLED_SECTIONS="DETAIL"
-    #  Or setting this macro value ENABLED_SECTIONS="DETAIL" in /doxygen/integer_doxyfile.txt for Standalone Doxygen documentaation.
-    # This might be useful for maintainers.
-
-  :
-    <doxygen:param>PROJECT_NAME="Integer"
-    <doxygen:param>RECURSIVE=NO # Specify all folders and files above explicitly.
-    <doxygen:param>ENABLE_PREPROCESSING=YES
-    <doxygen:param>EXPAND_ONLY_PREDEF=YES
-    <doxygen:param>EXTRACT_ALL=NO
-    <doxygen:param>EXTRACT_PRIVATE=NO
-    <doxygen:param>HIDE_UNDOC_MEMBERS=YES
-    <doxygen:param>MACRO_EXPANSION=YES
-    <doxygen:param>SORT_MEMBER_DOCS=NO
-    <doxygen:param>SHOW_INCLUDE_FILES=NO
-    <doxygen:param>MAX_INITIALIZER_LINES=0
-    <doxygen:param>VERBATIM_HEADERS=NO
-    <doxygen:param>WARNINGS=NO # If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings for undocumented members.
-    # If EXTRACT_ALL is set to YES then this flag will automatically be disabled.
-    <doxygen:param>WARN_IF_UNDOCUMENTED=YES # If WARN_IF_UNDOCUMENTED is set to YES,
-    # then doxygen will generate warnings for all undocumented members.
-    <doxygen:param>WARN_IF_DOC_ERROR=YES # If WARN_IF_DOC_ERROR is set to YES, Doxygen will generate warnings for
-    # potential errors in the documentation.
-    <doxygen:param>WARN_LOGFILE=AutoDoxywarnings.log # This may not be empty (usually not a good sign!), depending on options chosen.
-    # Much better to send message to a logfile than the default stderr.
-    # and make sure that there are no Doxygen errors or significant warnings in the log file.
-
-    #<reftitle>"Reference" # Default is "Reference" but helpful to specify library.
-    <xsl:param>"boost.doxygen.reftitle=Boost.Integer C++ Reference"
-    # See Doxygen configuration for detailed explanation of these options.
-    # Usually these match those in /doc/doxygen/integer_doxyfile.txt.
-  ;

+xml integer : integer.qbk ;
 boostbook standalone
    :
        integer
@@ -90,7 +14,6 @@ boostbook standalone
        # HTML options first:
        # Use graphics not text for navigation:
        <xsl:param>navig.graphics=1
-        <xsl:param>chapter.autolabel=0 # No Chapter numbering.
        # 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:
@@ -103,7 +26,7 @@ boostbook standalone
        <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
@@ -124,20 +47,14 @@ boostbook standalone
        # better use SVG's instead:
        <format>pdf:<xsl:param>admon.graphics.extension=".svg"
        <format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/
-        # Use Arial for PDF.
-        <format>pdf:<xsl:param>title.font.family="sans-serif"
-        <format>pdf:<xsl:param>body.font.family="sans-serif"
-        <format>pdf:<xsl:param>monospace.font.family="sans-serif"
-
-       <dependency>autodoc # Add Doxygen info.
-
+        <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 <name>boost.pdf ;
-
-
-install pdf-install : standalone : <install-type>PDF <location>. <name>integer.pdf ;
-
+install pdfinstall : standalone/<format>pdf : <location>. <install-type>PDF ;
 explicit pdfinstall ;

-
+###############################################################################
+alias boostdoc ;
+explicit boostdoc ;
+alias boostrelease : standalone ;
+explicit boostrelease ;
--- a/doc/doxygen/boost-no-inspect
+++ b/doc/doxygen/boost-no-inspect
--- a/doc/doxygen/integer_doxyfile.txt
+++ b/doc/doxygen/integer_doxyfile.txt
--- a/doc/gcd/math-gcd.qbk
+++ b/doc/gcd/math-gcd.qbk
@@ -1,5 +1,5 @@

-[mathpart gcd_lcm Integer Utilities (Greatest Common Divisor and Least Common Multiple)]
+[section:gcd_lcm Greatest Common Divisor and Least Common Multiple]

 [section Introduction]

@@ -24,9 +24,20 @@ programming problems.
      class lcm_evaluator;

   template < typename IntegerType >
-      IntegerType  gcd( IntegerType const &a, IntegerType const &b );
+      constexpr IntegerType  gcd( IntegerType const &a, IntegerType const &b );
   template < typename IntegerType >
-      IntegerType  lcm( IntegerType const &a, IntegerType const &b );
+      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;

@@ -54,8 +65,9 @@ programming problems.
      typedef IntegerType  second_argument_type;

      // Function object interface
-      result_type  operator ()( first_argument_type const &a,
-      second_argument_type const &b ) const;
+      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
@@ -70,6 +82,9 @@ 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]
@@ -86,8 +101,9 @@ gcd_evaluator class template.
      typedef IntegerType  second_argument_type;

      // Function object interface
-      result_type  operator ()( first_argument_type const &a,
-      second_argument_type const &b ) const;
+      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
@@ -103,6 +119,9 @@ 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]
@@ -110,24 +129,48 @@ specialize on the lcm_evaluator class template.
 [*Header: ] [@../../../../boost/math/common_factor_rt.hpp <boost/math/common_factor_rt.hpp>]

   template < typename IntegerType >
-   IntegerType  boost::math::gcd( IntegerType const &a, IntegerType const &b );
+   constexpr IntegerType  boost::math::gcd( IntegerType const &a, IntegerType const &b );

   template < typename IntegerType >
-   IntegerType  boost::math::lcm( IntegerType const &a, IntegerType const &b );
+   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.
-The function templates are parameterized on the function arguments'
-IntegerType, which is also the return type. Internally, these function
-templates use an object of the corresponding version of the
-gcd_evaluator and lcm_evaluator class templates, respectively.
+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;
@@ -219,6 +262,8 @@ code factoring and eases maintainence.

 [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.
@@ -235,7 +280,7 @@ pool library. The code had updates by Helmut Zeisel.

 [endsect]

-[endmathpart]
+[endsect]

 [/
 Copyright 2005, 2013 Daryle Walker.
--- a/doc/html/boost_integer/cstdint.html
+++ b/doc/html/boost_integer/cstdint.html
@@ -3,7 +3,7 @@
 <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.78.1">
+<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">
--- a/doc/html/boost_integer/gcd_lcm.html
+++ 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 &amp; 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 &lt;boost/math/common_factor.hpp&gt;</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 &lt;boost/math/common_factor.hpp&gt;
+        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">&lt;</span> <span class="keyword">typename</span> <span class="identifier">IntegerType</span> <span class="special">&gt;</span>
+   <span class="keyword">class</span> <span class="identifier">gcd_evaluator</span><span class="special">;</span>
+<span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">IntegerType</span> <span class="special">&gt;</span>
+   <span class="keyword">class</span> <span class="identifier">lcm_evaluator</span><span class="special">;</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">IntegerType</span> <span class="special">&gt;</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">&amp;</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">b</span> <span class="special">);</span>
+<span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">IntegerType</span> <span class="special">&gt;</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">&amp;</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">b</span> <span class="special">);</span>
+<span class="keyword">template</span> <span class="special">&lt;</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">&gt;</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">&amp;</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">Args</span> <span class="keyword">const</span><span class="special">&amp;...</span> <span class="special">);</span>
+<span class="keyword">template</span> <span class="special">&lt;</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">&gt;</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">&amp;</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">Args</span> <span class="keyword">const</span><span class="special">&amp;...</span> <span class="special">);</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">I</span><span class="special">&gt;</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">I</span><span class="special">&gt;::</span><span class="identifier">value_type</span><span class="special">,</span> <span class="identifier">I</span><span class="special">&gt;</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">&lt;</span><span class="keyword">typename</span> <span class="identifier">I</span><span class="special">&gt;</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">I</span><span class="special">&gt;::</span><span class="identifier">value_type</span><span class="special">,</span> <span class="identifier">I</span><span class="special">&gt;</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">&lt;</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">&gt;</span>
+   <span class="keyword">struct</span> <span class="identifier">static_gcd</span><span class="special">;</span>
+<span class="keyword">template</span> <span class="special">&lt;</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">&gt;</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">&lt;boost/math/common_factor_rt.hpp&gt;</a>
+      </p>
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">IntegerType</span> <span class="special">&gt;</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">&amp;</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">&amp;</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">&lt;boost/math/common_factor_rt.hpp&gt;</a>
+      </p>
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">IntegerType</span> <span class="special">&gt;</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">&amp;</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">&amp;</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 &amp; LCM Determination">Run-time GCD &amp; 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">&lt;boost/math/common_factor_rt.hpp&gt;</a>
+      </p>
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">IntegerType</span> <span class="special">&gt;</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">&amp;</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">b</span> <span class="special">);</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">IntegerType</span> <span class="special">&gt;</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">&amp;</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">b</span> <span class="special">);</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</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">&gt;</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">&amp;</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">Args</span> <span class="keyword">const</span><span class="special">&amp;...</span> <span class="special">);</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</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">&gt;</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">&amp;</span><span class="identifier">a</span><span class="special">,</span> <span class="identifier">IntegerType</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">b</span><span class="special">,</span> <span class="identifier">Args</span> <span class="keyword">const</span><span class="special">&amp;...</span> <span class="special">);</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">I</span><span class="special">&gt;</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">I</span><span class="special">&gt;::</span><span class="identifier">value_type</span><span class="special">,</span> <span class="identifier">I</span><span class="special">&gt;</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">&lt;</span><span class="keyword">typename</span> <span class="identifier">I</span><span class="special">&gt;</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">iterator_traits</span><span class="special">&lt;</span><span class="identifier">I</span><span class="special">&gt;::</span><span class="identifier">value_type</span><span class="special">,</span> <span class="identifier">I</span><span class="special">&gt;</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">&lt;boost/math/common_factor_ct.hpp&gt;</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">&lt;</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">&gt;</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">&lt;</span><span class="identifier">static_gcd_type</span><span class="special">,</span> <span class="identifier">implementation_defined</span><span class="special">&gt;</span>
+<span class="special">{</span>
+<span class="special">};</span>
+
+<span class="keyword">template</span> <span class="special">&lt;</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">&gt;</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">&lt;</span><span class="identifier">static_gcd_type</span><span class="special">,</span> <span class="identifier">implementation_defined</span><span class="special">&gt;</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">&lt;</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">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iterator</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</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">&lt;&lt;</span> <span class="string">"The GCD and LCM of 6 and 15 are "</span>
+   <span class="special">&lt;&lt;</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">&lt;&lt;</span> <span class="string">" and "</span>
+   <span class="special">&lt;&lt;</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">&lt;&lt;</span> <span class="string">", respectively."</span>
+   <span class="special">&lt;&lt;</span> <span class="identifier">endl</span><span class="special">;</span>
+
+   <span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"The GCD and LCM of 8 and 9 are "</span>
+   <span class="special">&lt;&lt;</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">&lt;</span><span class="number">8</span><span class="special">,</span> <span class="number">9</span><span class="special">&gt;::</span><span class="identifier">value</span>
+   <span class="special">&lt;&lt;</span> <span class="string">" and "</span>
+   <span class="special">&lt;&lt;</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">&lt;</span><span class="number">8</span><span class="special">,</span> <span class="number">9</span><span class="special">&gt;::</span><span class="identifier">value</span>
+   <span class="special">&lt;&lt;</span> <span class="string">", respectively."</span> <span class="special">&lt;&lt;</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">&lt;</span><span class="keyword">int</span><span class="special">&gt;()</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">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</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 &lt;boost/math/common_factor.hpp&gt;">Header &lt;boost/math/common_factor.hpp&gt;</a>
+</h3></div></div></div>
+<p>
+        This header simply includes the headers <a href="../../../../../boost/math/common_factor_ct.hpp" target="_top">&lt;boost/math/common_factor_ct.hpp&gt;</a>
+        and <a href="../../../../../boost/math/common_factor_rt.hpp" target="_top">&lt;boost/math/common_factor_rt.hpp&gt;</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 &#169; 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>
--- a/doc/html/boost_integer/history.html
+++ b/doc/html/boost_integer/history.html
@@ -3,7 +3,7 @@
 <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.78.1">
+<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">
--- a/doc/html/boost_integer/integer.html
+++ b/doc/html/boost_integer/integer.html
@@ -3,11 +3,11 @@
 <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.78.1">
+<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="mask.html" title="Integer Masks">
+<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>
@@ -20,13 +20,13 @@
 </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="mask.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+<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 class="toc">
+<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>
@@ -426,7 +426,7 @@
 </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="mask.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+<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>
--- a/doc/html/boost_integer/log2.html
+++ b/doc/html/boost_integer/log2.html
@@ -3,7 +3,7 @@
 <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.78.1">
+<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">
@@ -26,7 +26,7 @@
 <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 class="toc">
+<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
--- a/doc/html/boost_integer/mask.html
+++ b/doc/html/boost_integer/mask.html
@@ -3,10 +3,10 @@
 <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.78.1">
+<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="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">
@@ -20,13 +20,13 @@
 </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="log2.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+<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 class="toc">
+<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
@@ -374,7 +374,7 @@
 </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="log2.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
+<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>
--- a/doc/html/boost_integer/minmax.html
+++ b/doc/html/boost_integer/minmax.html
@@ -3,7 +3,7 @@
 <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.78.1">
+<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">
@@ -26,7 +26,7 @@
 <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 class="toc">
+<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>
--- a/doc/html/boost_integer/traits.html
+++ b/doc/html/boost_integer/traits.html
@@ -3,7 +3,7 @@
 <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.78.1">
+<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">
@@ -26,7 +26,7 @@
 <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 class="toc">
+<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>
--- a/doc/html/index.html
+++ b/doc/html/index.html
@@ -3,7 +3,7 @@
 <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.78.1">
+<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>
@@ -50,10 +50,12 @@
 </div>
 <div class="toc">
 <p><b>Table of Contents</b></p>
-<dl class="toc">
+<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>
@@ -158,6 +160,27 @@
            </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">&lt;boost/integer/common_factor_rt.hpp&gt;</a></code>
+                and <code class="literal"><a href="../../../../boost/integer/common_factor_ct.hpp" target="_top">&lt;boost/integer/common_factor_ct.hpp&gt;</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>.
@@ -219,7 +242,7 @@
 </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: June 01, 2014 at 19:57:36 GMT</small></p></td>
+<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>
--- a/doc/integer.idx
+++ b/doc/integer.idx
@@ -1,28 +0,0 @@
-# integer.idx for Boost.integer/Spreadinteger Quickbook, Doxygen and Auto-index.
-
-# Note needs more customization to be useful in practice! TODO?
-
-#!debug "\<\w*\>"
-
-# integer Header files.
-!scan-path "../include/boost/" ".*\.hpp" false
-!scan-path "../include/boost/integer" ".*\.hpp" false
-
-# All example source files, assuming no sub-folders.
-# integer example files.
-#!scan-path "../example" ".*\.cpp" true
-
-# Allow alternative spellings colour | color, and plurals etc.
-color  \<\w*(colour|color)\w*\>
-example \<example\w*\>
-font  \<font\w*\>
-greek
-ioflags
-origin
-outlier
-maximum \<max\w*\>
-minimum \<min\w*\>
-precision
-range  \<\w*\range\w*\>
-title
-Unicode \<unicode\w*\>
--- a/doc/integer.qbk
+++ b/doc/integer.qbk
--- a/example/integer_common_factor_example.cpp
+++ b/example/integer_common_factor_example.cpp
@@ -1,62 +0,0 @@
-// boost integer_common_factor_example.cpp 
-
-// Copyright Paul A. Bristow 2015
-// 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)
-
-// Caution: this file contains Quickbook markup as well as code
-// and comments, don't change any of the special comment markups!
-
-// #include <boost/integer/common_factor.hpp> // Includes both ct and rt but now deprecated.
-
-//[integer_common_factor_example_0]
-#include <boost/integer/common_factor_ct.hpp> // For compile-time GCD & LCM Determination.
-#include <boost/integer/common_factor_rt.hpp> // For run-time GCD & LCM Determination.
-//] [/integer_common_factor_example_0]
-#include <iostream>
-#include <algorithm>
-#include <iterator>
-
-#include <limits>  // for numeric_limits min and max.
-
-int main()
-{
-//[integer_common_factor_example_1
-  std::cout << "The run-time GCD and LCM of 6 and 15 are "
-    << boost::integer::gcd(6, 15) << " and "
-    << boost::integer::lcm(6, 15) << ", respectively."
-    << std::endl;
-  // The GCD and LCM of 6 and 15 are 3 and 30, respectively.
-//] [/integer_common_factor_example_1]
-
-//[integer_common_factor_example_2
-
-  std::cout << "The compile-time GCD and LCM of 8 and 9 are "
-    << boost::integer::static_gcd<8, 9>::value
-    << " and "
-    << boost::integer::static_lcm<8, 9>::value
-    << ", respectively." << std::endl;
-  // The GCD and LCM of 8 and 9 are 1 and 72, respectively.
-//] [/integer_common_factor_example_2]
-
-//[integer_common_factor_example_3
-  int  a[] = { 4, 5, 6 }, b[] = { 7, 8, 9 }, c[3];
-  std::transform(a, a + 3, b, c, boost::integer::gcd_evaluator<int>());
-  std::copy(c, c + 3, std::ostream_iterator<int>(std::cout, " "));
-//] [/integer_common_factor_example_3]
-
-} // int main
-
-/*
-//[integer_common_factor_example_output_1
-The run-time GCD and LCM of 6 and 15 are 3 and 30, respectively.
-
-The compile-time GCD and LCM of 8 and 9 are 1 and 72, respectively.
-//] [/integer_common_factor_example_output_1]
-
-//[integer_common_factor_example_output_2
-1 1 3
-//] [/integer_common_factor_example_output_2]
-*/
--- a/example/integer_log2_example.cpp
+++ b/example/integer_log2_example.cpp
@@ -1,41 +0,0 @@
-// boost integer_log2_example.cpp 
-
-// Copyright Paul A. Bristow 2015
-// 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)
-
-// Caution: this file contains Quickbook markup as well as code
-// and comments, don't change any of the special comment markups!
-
-//[integer_log2_example_0
-#include <boost/integer/static_log2.hpp> // For boost::static_log2
-//] [/integer_log2s_example_0]
-#include <iostream> 
-#include <limits>  // for numeric_limits min and max.
-
-//[integer_log2_example_
-//] [/integer_log2s_example_]
-
-int main()
-{
-//[integer_log2_example_1
-  int n = boost::static_log2<256>::value;
-//] [/integer_log2_example_1]
-
-  std::cout << n << std::endl; // 8
-
-  //[integer_log2_example_2
-  int n2 = boost::static_log2<65536>::value;
-//] [/integer_log2_example_2]
-
-  std::cout << n2 << std::endl; // 16
-
-} // int main
-
-/*
-//[integer_log2_example_output
-8
-//] [/integer_log2_example_output]
-*/
--- a/example/integer_mask_example.cpp
+++ b/example/integer_mask_example.cpp
@@ -1,69 +0,0 @@
-// boost integer_mask_example.cpp 
-
-// Copyright Paul A. Bristow 2015
-// 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)
-
-// Caution: this file contains Quickbook markup as well as code
-// and comments, don't change any of the special comment markups!
-
-//[integer_mask_example_0
-#include <boost/integer/integer_mask.hpp> // For boost::high_bit_mask_t etc
-//] [/integer_masks_example_0]
-#include <iostream> 
-#include <limits>  // for numeric_limits min and max.
-
-//[integer_mask_example_
-//] [/integer_masks_example_]
-
-int main()
-{
-//[integer_mask_example_1
-  typedef boost::high_bit_mask_t<29>  mask1_type;
-  typedef boost::low_bits_mask_t<15>  mask2_type;
-//] [/integer_masks_example_1]
-
-//[integer_mask_example_2
-  // high_bit_mask_t
-  std::cout << std::hex << mask1_type::bit_position << std::endl; // 1d
-  std::cout << std::hex << mask1_type::high_bit << std::endl; // 20000000
-  std::cout << std::hex << mask1_type::high_bit_fast << std::endl; // 20000000
-
-  // low_bits_mask_t
-  std::cout << std::hex << mask2_type::bit_count << std::endl; // F
-  std::cout << std::hex << mask2_type::sig_bits << std::endl; // 7fff
-  std::cout << std::hex << mask2_type::sig_bits_fast << std::endl; // 7fff
-//] [/integer_masks_example_2]
-
-//[integer_mask_example_3
-  mask1_type::least  my_var1;
-  mask2_type::fast   my_var2;
-//] [/integer_masks_example_3]
-
-//[integer_mask_example_4
-  my_var1 |= mask1_type::high_bit;
-  std::cout << std::hex << my_var1 << std::endl; // eccccccc
-//] [/integer_masks_example_4]
-
-//[integer_mask_example_5
-  my_var2 &= mask2_type::sig_bits;
-  std::cout << std::hex << my_var2 << std::endl; // 4ccc
-//] [/integer_masks_example_5]
-
-} // int main
-
-/*
-//[integer_mask_example_output
-1d
-20000000
-20000000
-f
-7fff
-7fff
-eccccccc
-4ccc
-//] [/integer_mask_example_output]
-
-*/
--- a/example/integer_static_minmax_example.cpp
+++ b/example/integer_static_minmax_example.cpp
@@ -1,73 +0,0 @@
-// boost integer_static_minmax_example.cpp 
-
-// Copyright Paul A. Bristow 2015
-// 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)
-
-// Caution: this file contains Quickbook markup as well as code
-// and comments, don't change any of the special comment markups!
-
-#include <boost/integer/static_min_max.hpp> // For boost::static_signed_min
-#include <iostream> 
-#include <limits>  // for numeric_limits min and max.
-
-//[integer_min_max_example_0
-
-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;
-}; // class adder
-
-//] [/integer_min_max_example_0]
-
-int main()
-{
-//[integer_min_max_example_1
-
-  std::cout << "boost::static_signed_min< 9, 14>::value = "<< boost::static_signed_min< 9, 14>::value << std::endl;
-  std::cout << "boost::static_signed_max< 9, 14>::value = "<< boost::static_signed_max< 9, 14>::value << std::endl;
-
-//] [/integer_min_max_example_1]
-
-//[integer_min_max_example_2
-  int const   a1[] = { 0, 4, 3 };  // 340
-  int const   a2[] = { 9, 8 };     //  89
-  int         s[4];
-
-  adder<3, 2>  obj;
-  // adder<sizeof(a1), sizeof(a2)>  obj;
-
-  std::cout << "obj.addend1_size = " << obj.addend1_size << std::endl; // 3
-  std::cout << "obj.addend2_size = " << obj.addend2_size << std::endl; // 2
-  std::cout << "obj.sum_size = " << obj.sum_size << std::endl; // 4
-//] [/integer_min_max_example_2]
-
-  // obj(a1, a2, s);  // 's' should be 429 or { 9, 2, 4, 0 }
-  //void adder<3,2>::operator()(int const (&)[3],int const (&)[2],int (&)[4])const 
-
-  std::cout << s[0] << s[1]  << s[2] << s[3]<< std::endl; // 's' should be 429 or { 9, 2, 4, 0 }
-
-} // int main
-
-/*
-//[integer_min_max_example_output
-
-boost::static_signed_min< 9, 14>::value = 9
-boost::static_signed_max< 9, 14>::value = 14
-obj.addend1_size = 3
-obj.addend2_size = 2
-obj.sum_size = 4
-//] [/integer_min_max_example_output]
-*/
--- a/example/integer_traits_example.cpp
+++ b/example/integer_traits_example.cpp
@@ -1,55 +0,0 @@
-// boost integer_traits_example.cpp 
-
-// Copyright Paul A. Bristow 2015
-// 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)
-
-// Caution: this file contains Quickbook markup as well as code
-// and comments, don't change any of the special comment markups!
-
-#include <boost/integer_traits.hpp>
-#include <iostream> 
-#include <limits>  // for numeric_limits min and max.
-
-//[integer_traits_example_1
-template<int N>
-void f()
-{ // Entirely contrived templated function.
-  std::cout << N << std::endl; // Do something pointless.
-}
-//] [/integer_traits_example_1]
-
-
-int main()
-{
-  std::cout << "Type int, min =  " 
-    << (std::numeric_limits<int>::min)() 
-    << ", const_min =  " << boost::integer_traits<int>::const_min
-    << std::endl; // Type int, min =  -2147483648, const_min =  -2147483648
-
-//[integer_traits_example_2
-  f<2>();
-//] [/integer_traits_example_2]
-
-//[integer_traits_example_3
-  int i = 2;
- // f<i>(); // A local variable cannot be used as a non-type argument.
-//] [/integer_traits_example_3]
-
-//[integer_traits_example_4
-  const int ci = 2;
-  f<ci>(); // But a const variable can.
-//] [/integer_traits_example_4]
-//[integer_traits_example_5
-
-  // f<std::numeric_limits<int>::min()>(); // Function call must have a constant value in a constant expression.
-//] [/integer_traits_example_5]
-//[integer_traits_example_6
-
-  f<boost::integer_traits<int>::const_min>();
-//] [/integer_traits_example_6]
-
-} // int main
-
--- a/example/integer_type_selection_example.cpp
+++ b/example/integer_type_selection_example.cpp
@@ -1,251 +0,0 @@
-// boost integer_type_selection.cpp 
-
-// Copyright Paul A. Bristow 2015
-// 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)
-
-// Caution: this file contains Quickbook markup as well as code
-// and comments, don't change any of the special comment markups!
-
-#include <boost/integer.hpp>
-#include <iostream> 
-#include <limits>  // for numeric_limits min and max.
-// Note use of extra brackets to avoid potential clash for any min and max macros:
-// (std::numeric_limits<T>::max)()  (std::numeric_limits<T>::min)()
-
-//! Show info about type
-template <const int Bits, typename T>
-void show_type()
-{ 
-  std::cout << typeid(T).name() 
-    << " is a signed int using at least " << Bits << " bits uses "
-    << std::numeric_limits<boost::int_t<Bits>::least>::digits 
-    << " bits, needing at most "
-    << std::numeric_limits<boost::int_t<Bits>::least>::digits10
-    << " decimal digits, "    " and representing a maximum decimal value of "
-    << static_cast<int>((std::numeric_limits<boost::int_t<Bits>::least>::max)())
-    << std::endl;
-} // template <const int Bits, typename T> void show_type()
-
-template <typename T>
-void show_consts()
-{ // 
-  std::cout << "Type " << typeid(T).name();
-  if (std::numeric_limits<T>::is_specialized)
-  {
-    std::cout << " is specialized for std::numeric_limits,";
-    if (std::numeric_limits<T>::is_integer)
-    {
-      std::cout << " and is integer type." << std::endl;
-      // If a constant expression for `min` and `max` are required, see  
-      // Boost integer_traits.
-      std::cout << "const_max = " << boost::integer_traits<T>::const_max << std::endl;
-      std::cout << "const_min = " << boost::integer_traits<T>::const_min << std::endl;
-    }
-  }
-} // void show_consts()
-
-template <typename T>
-void show_type()
-{
-  std::cout << "Type " << typeid(T).name(); // name of resultant type.
-  if (std::numeric_limits<T>::is_specialized)
-  {
-    if (std::numeric_limits<T>::is_integer)
-    {
-      std::cout << " is an unsigned int with at least 13 bits using "
-      << std::numeric_limits<T>::digits + (std::numeric_limits<T>::is_signed ? 1 : 0) << " bits,\n"
-      // See http://en.cppreference.com/w/cpp/types/numeric_limits/digits for details on the meaning of digits10.
-      // The value of std::numeric_limits<T>::digits is the number of digits in base-radix that can be represented 
-      // by the type T without change. 
-      // For integer types, this is the number of bits *not counting the sign bit*, so add one for the total.
-      // (For floating-point types, this is the number of digits in the mantissa).
-      "guaranteeing at most " << std::numeric_limits<T>::digits10 << " decimal digits precision,\n"
-      "and using at most " << std::numeric_limits<T>::digits10 + 1
-      << " decimal digits,\n"
-      // See http://en.cppreference.com/w/cpp/types/numeric_limits/digits10 for details on the meaning of digits10.
-      // The value of std::numeric_limits<T>::digits is the number of digits in base-radix that can be represented 
-      // by the type T without change. 
-      // For integer types, the maximum number of digits that may be required is one more than digits10.
-      "a maximum decimal value of " << static_cast<long>((std::numeric_limits<T>::max)())
-      << " and a minimum decimal value of " << static_cast<long>((std::numeric_limits<T>::min)()) << "."
-      << std::endl;
-   }
-    else
-    {
-      std::cout << "is floating-point." << std::endl;
-    }
-  }
-  else
-  { //  is NOT specialized.
-    std::cout << " is NOT specialized for std::numeric_limits!" << std::endl;
-  }
-} // template <typename T> void show_type()
-
-
-template <typename T>
-void show_type_limits()
-{ // 
-
-  std::cout <<"Type " << typeid(T).name();
-  if (std::numeric_limits<T>::is_specialized)
-  {
-    std::cout << " is specialized for std::numeric_limits." << std::endl;
-    if (std::numeric_limits<T>::is_integer)
-      {
-        std::cout << "is integer." << std::endl;
-
-        std::cout << (std::numeric_limits<T>::is_bounded ? "is bounded." : "") << std::endl;
-        std::cout << (std::numeric_limits<T>::is_exact ? "is exact." : "") << std::endl;
-        std::cout << (std::numeric_limits<T>::is_modulo ? "is modulo." : "") << std::endl;
-        std::cout << "radix = " << std::numeric_limits<T>::radix << std::endl;
-        std::cout << (std::numeric_limits<T>::is_signed ? "is signed." : "is unsigned.") << std::endl;
-
-        std::cout << "max = " << static_cast<long>((std::numeric_limits<T>::max)()) << std::endl;
-        std::cout << "min = " << static_cast<long>((std::numeric_limits<T>::min)()) << std::endl;
-        // Can't list const_max or const_min here because compiler will protest that
-        // const_max' : is not a member of 'boost::integer_traits<T>' when T is double.
-        //std::cout << "const_max = " << boost::integer_traits<T>::const_max << std::endl;
-        //std::cout << "const_min = " << boost::integer_traits<T>::const_min << std::endl;
-
-        std::cout << "digits = " << std::numeric_limits<T>::digits << std::endl;
-        std::cout << "bits = " << std::numeric_limits<T>::digits +1 << std::endl;
-        // digits is the number of bits not counting the sign bit for integer types.
-
-        std::cout << "digits10 = " << std::numeric_limits<T>::digits10 << std::endl;
-        // max_digits10 is not defined for integer types.
-        //std::cout << "max_digits10 = " << std::numeric_limits<T>::max_digits10 << std::endl;
-      }
-      else
-      { // Not integral, so might be floating-point, or ?
-        std::cout << "is NOT integral type." << std::endl;
-        if ((std::numeric_limits<T>::max_exponent != 0) && (std::numeric_limits<T>::max_exponent10 != 0))
-        { // floating-point type including fundamental float, double and multiprecision like cpp_dec_float_50 and cpp_bin_float_50.
-          std::cout << "is floating-point type." << std::endl;
-          std::cout << "digits = " << std::numeric_limits<T>::digits << std::endl;
-          // digits is the number of bits in the significand (not counting the sign bit) for floating-point types.
-          std::cout << "digits10 = " << std::numeric_limits<T>::digits10 << std::endl;
-          // http://en.cppreference.com/w/cpp/types/numeric_limits/digits10  
-          std::cout << "max_digits10 = " << std::numeric_limits<T>::max_digits10 << std::endl;
-          std::cout << "is_modulo = " << std::numeric_limits<T>::is_modulo << std::endl;
-          std::cout << "is_iec559 = " << std::numeric_limits<T>::is_iec559 << std::endl;
-          std::cout << (std::numeric_limits<T>::is_exact ? "is exact." : "") << std::endl;
-          std::cout << (std::numeric_limits<T>::is_signed ? "is signed." : "is unsigned.") << std::endl;
-          std::cout << "has_quiet_NaN = " << std::numeric_limits<T>::has_quiet_NaN << std::endl;
-          std::cout << "has_infinity = " << std::numeric_limits<T>::has_infinity << std::endl;
-          std::cout << "has_denorm_loss = " << std::numeric_limits<T>::has_denorm_loss << std::endl;
-          std::cout << "max_exponent = " << std::numeric_limits<T>::max_exponent << std::endl;
-          std::cout << "min_exponent = " << std::numeric_limits<T>::min_exponent << std::endl;
-          std::cout << "max_exponent10 = " << std::numeric_limits<T>::max_exponent10 << std::endl;
-          std::cout << "min_exponent10 = " << std::numeric_limits<T>::min_exponent10 << std::endl;
-        }
-        else
-        { // Unknown type
-          std::cout << "Unknown type." << std::endl;
-        }
-      }
-  }
-  else 
-  { // Not specialized!
-    std::cout << " is NOT specialized for std::numeric_limits!" << std::endl;
-  }
-} // show_type_limits
-
-
-int main()
-{
-  try
-  { 
-
-// Select, construct and assign an unsigned integer of at least 13 bits.
-//[integer_type_selection_1
-     boost::uint_t<13>::least my_var13 = 42;  
-//] [/integer_type_selection_1]
-
-//[integer_type_selection_2
-     show_type<boost::uint_t<13>::least>();
-//] [/integer_type_selection_2]
-
-    // Select fastest signed integer of at least 7 bits.
-//[integer_type_selection_3
-    typedef boost::int_t<7>::fast int_7; 
-//] [/integer_type_selection_3]
-
-//[integer_type_selection_4
-    show_type<int_7>();
-//] [/integer_type_selection_4]
-
-
-  // Choose an integer size that can hold at least a value of 1000
-  // Assignment of this value is guaranteed not to be truncated:
-//[integer_value_type_selection_5
-
-    boost::int_max_value_t<1000>::least thousand = 1000;
-//] [/integer_value_type_selection_5]
-
-    std::cout << thousand << std::endl;
-
-//[integer_value_type_selection_6
-
-    std::cout << (std::numeric_limits<boost::int_max_value_t<1000>::least>::max)() << std::endl;
-
-//] [/integer_value_type_selection_6]
-
-//[integer_value_type_selection_7
-
-  thousand = 100000; // Probably too big!
-
-  // warning C4305 :  warning C4305: '=' : truncation from 'int' to 'short'
-  // warning C4309:  '='  : truncation of constant value
-
-//] [/integer_value_type_selection_7]
-
-//[integer_value_type_selection_8
-
-    boost::int_t<32>::exact my_exact32 = 1000000;
-  
-    std::cout << "boost::int_t<32>::exact has "
-      << std::numeric_limits<boost::int_t<32>::exact>::digits
-      << " bits and 1 sign bit." << std::endl;
-//  boost::int_t<32>::exact has 31 bits and 1 sign bit.
-
-//] [/integer_value_type_selection_8]
-
-// If we ask for an unachievable number of bits or value
-
-    //boost::int_t<128>::exact exact128;
-    //error C2338 : No suitable signed integer type with the requested number of bits is available.
-    // see reference to class template instantiation 'boost::int_t<128>' being compiled
-
-    show_consts<boost::int_t<32>::exact>();
-    //  const_max = 2147483647  const_min = -2147483648
-
-    show_type<16, boost::int_max_value_t<1000>::least>();
-
-  }
-  catch (std::exception ex)
-  {
-    std::cout << ex.what() << std::endl;
-  }
-  return 0;
-} // int main
-
-
-/*
-
-//[integer_type_selection_output_1
-Type short is an unsigned int with at least 13 bits using 16 bits,
-guaranteeing at most 4 decimal digits precision,
-and using at most 5 decimal digits,
-//] [/integer_type_selection_output_1]
-
-//[integer_type_selection_output_2
-Type signed char is an unsigned int with at least 13 bits using 8 bits,
-guaranteeing at most 2 decimal digits precision,
-and using at most 3 decimal digits,
-a maximum decimal value of 127 and a minimum decimal value of -128.
-//] [/integer_type_selection_output_2]
-
-*/
--- a/example/jamfile.v2
+++ b/example/jamfile.v2
@@ -1,33 +0,0 @@
-# libs/integer/example Jamfile
-# Copyright (c) Vladimir Batov 2009-2014
-# Copyright Paul A. Bristow 2015
-
-# Distributed under the Boost Software License, Version 1.0.
-# See copy at http://www.boost.org/LICENSE_1_0.txt.
-
-# bring in the rules for testing
-import testing ;
-
-project convert_examples
-    : requirements
-        <warnings>on
-        <toolset>gcc:<warnings>all
-        <toolset>msvc:<warnings>all
-        <toolset>gcc:<cxxflags>"-Wno-unused-local-typedefs -Wno-unused-variable -Wno-long-long"
-        <toolset>msvc:<cxxflags>"/wd4996 /wd4512 /wd4610 /wd4510 /wd4127 /wd4701 /wd4127 /wd4305 /wd4100 /wd4512 /wd4714"
-        <toolset>msvc:<asynch-exceptions>on
-        <toolset>msvc:<define>_CRT_SECURE_NO_DEPRECATE
-        <toolset>msvc:<define>_SCL_SECURE_NO_DEPRECATE
-        <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS
-        <toolset>msvc:<define>_CRT_SECURE_NO_WARNINGS
-        <include>../include
-    ;
-
-run integer_mask_example.cpp ;
-run integer_traits_example.cpp ;
-run integer_type_selection_example.cpp ;
-
-
-
-
-
--- a/include/boost/integer.hpp
+++ b/include/boost/integer.hpp
@@ -6,9 +6,6 @@

 //  See http://www.boost.org/libs/integer for documentation.

-//! \file
-//! \brief Compile-time evaluation of specified (least and fast) integer types.
-
 //  Revision History
 //   22 Sep 01  Added value-based integer templates. (Daryle Walker)
 //   01 Apr 01  Modified to use new <boost/limits.hpp> header. (John Maddock)
@@ -51,7 +48,6 @@ namespace boost
     typedef fast     type;
  }; // imps may specialize

-//! \cond DETAIL
  namespace detail{

  //  convert category to type
@@ -95,7 +91,8 @@ namespace boost
  template <> struct exact_signed_base_helper<sizeof(int)* CHAR_BIT> { typedef int exact; };
  template <> struct exact_unsigned_base_helper<sizeof(unsigned int)* CHAR_BIT> { typedef unsigned int exact; };
 #endif
-#if ULONG_MAX != UINT_MAX
+#if ULONG_MAX != UINT_MAX && ( !defined __TI_COMPILER_VERSION__ || \
+    ( __TI_COMPILER_VERSION__ >= 7000000 && !defined __TI_40BIT_LONG__ ) )
  template <> struct exact_signed_base_helper<sizeof(long)* CHAR_BIT> { typedef long exact; };
  template <> struct exact_unsigned_base_helper<sizeof(unsigned long)* CHAR_BIT> { typedef unsigned long exact; };
 #endif
@@ -108,8 +105,8 @@ namespace boost
  template <> struct exact_unsigned_base_helper<sizeof(boost::ulong_long_type)* CHAR_BIT> { typedef boost::ulong_long_type exact; };
 #endif

+
  } // namespace detail
-  //! \endcond // DETAIL

  //  integer templates specifying number of bits  ---------------------------//

@@ -170,7 +167,7 @@ namespace boost
  //  integer templates specifying extreme value  ----------------------------//

  //  signed
-#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG)
  template< boost::long_long_type MaxValue >   // maximum value to require support
 #else
  template< long MaxValue >   // maximum value to require support
@@ -179,7 +176,7 @@ namespace boost
  {
      typedef typename boost::detail::int_least_helper
        <
-#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG)
          (MaxValue <= ::boost::integer_traits<boost::long_long_type>::const_max) +
 #else
           1 +
@@ -192,7 +189,7 @@ namespace boost
      typedef typename int_fast_t<least>::type  fast;
  };

-#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG)
  template< boost::long_long_type MinValue >   // minimum value to require support
 #else
  template< long MinValue >   // minimum value to require support
@@ -201,7 +198,7 @@ namespace boost
  {
      typedef typename boost::detail::int_least_helper
        <
-#if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
+#if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) && defined(BOOST_HAS_LONG_LONG)
          (MinValue >= ::boost::integer_traits<boost::long_long_type>::const_min) +
 #else
           1 +
@@ -259,6 +256,7 @@ namespace boost
      typedef typename int_fast_t<least>::type  fast;
  };

+
 } // namespace boost

 #endif  // BOOST_INTEGER_HPP
--- a/include/boost/integer/common_factor.hpp
+++ b/include/boost/integer/common_factor.hpp
@@ -5,9 +5,7 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)

-//  See http://www.boost.org for updates, documentation, and revision history.
-//! \file
-//! \brief Include both GCD and LCM.
+//  See http://www.boost.org for updates, documentation, and revision history. 

 #ifndef BOOST_INTEGER_COMMON_FACTOR_HPP
 #define BOOST_INTEGER_COMMON_FACTOR_HPP
--- a/include/boost/integer/common_factor_ct.hpp
+++ b/include/boost/integer/common_factor_ct.hpp
@@ -5,25 +5,21 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)

-//  See http://www.boost.org for updates, documentation, and revision history.
-//! \file
-//! \brief Evaluate Greatest Common Divisor and Least Common Multiple at compile-time.
+//  See http://www.boost.org for updates, documentation, and revision history. 

 #ifndef BOOST_INTEGER_COMMON_FACTOR_CT_HPP
 #define BOOST_INTEGER_COMMON_FACTOR_CT_HPP

-#include <boost/integer_fwd.hpp>  // Include for declaration of static_gcd_type and static_gcd.
+#include <boost/integer_fwd.hpp>  // self include
 #include <boost/config.hpp>  // for BOOST_STATIC_CONSTANT, etc.
-#include <boost/cstdint.hpp> // for boost::uintmax_t

 namespace boost
 {
 namespace integer
 {
-  // Warning: From 1.58 this is in namespace boost::integer and no longer in namespace boost::math.

 //  Implementation details  --------------------------------------------------//
-//! \cond DETAIL
+
 namespace detail
 {
    // Build GCD with Euclid's recursive algorithm
@@ -75,7 +71,7 @@ namespace detail
    };

 }  // namespace detail
-//! \endcond // DETAIL
+

 //  Compile-time greatest common divisor evaluator class declaration  --------//

--- a/include/boost/integer/common_factor_rt.hpp
+++ b/include/boost/integer/common_factor_rt.hpp
--- a/include/boost/integer/integer_log2.hpp
+++ b/include/boost/integer/integer_log2.hpp
@@ -1,18 +1,15 @@
 // -----------------------------------------------------------
 // integer_log2.hpp
 //
+//   Gives the integer part of the logarithm, in base 2, of a
+// given number. Behavior is undefined if the argument is <= 0.
+//
 //         Copyright (c) 2003-2004, 2008 Gennaro Prota
 //
 // 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)
 //
-//! \file
-//! \brief  Function integer_log2 gives the integer part of the logarithm, in base 2, of a
-//!  given number (at run-time). Behavior is undefined if the argument is <= 0.
-//
-//! \note For analogous compile-time computation of log2 see static_log2.
-//! \sa http::www.boost.org/doc/integer
 // -----------------------------------------------------------

 #ifndef BOOST_INTEGER_INTEGER_LOG2_HPP
@@ -27,8 +24,6 @@


 namespace boost {
-
-//! \cond DETAIL
 namespace detail {

  template <typename T>
@@ -51,6 +46,7 @@ namespace boost {
  }


+
  // helper to find the maximum power of two
  // less than p (more involved than necessary,
  // to avoid PTS)
@@ -86,8 +82,9 @@ namespace boost {
 #endif

  };
+
 } // detail
-//! \endcond // DETAIL
+

 // ---------
 // integer_log2
@@ -107,6 +104,9 @@ namespace boost {
 }


+
 }

-#endif // BOOST_INTEGER_INTEGER_LOG2_HPP  include guard
+
+
+#endif // include guard
--- a/include/boost/integer/integer_mask.hpp
+++ b/include/boost/integer/integer_mask.hpp
@@ -5,10 +5,7 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)

-//  See http://www.boost.org for updates, documentation, and revision history.
-
-//! \file
-//! \brief Compile-time integer mask evaluation.
+//  See http://www.boost.org for updates, documentation, and revision history. 

 #ifndef BOOST_INTEGER_INTEGER_MASK_HPP
 #define BOOST_INTEGER_INTEGER_MASK_HPP
@@ -38,6 +35,7 @@
 namespace boost
 {

+
 //  Specified single-bit mask class declaration  -----------------------------//
 //  (Lowest bit starts counting at 0.)

@@ -59,19 +57,27 @@ struct high_bit_mask_t
 //  Makes masks for the lowest N bits
 //  (Specializations are needed when N fills up a type.)

+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4310)  // cast truncates constant value
+#endif
+
 template < std::size_t Bits >
 struct low_bits_mask_t
 {
    typedef typename uint_t<Bits>::least  least;
    typedef typename uint_t<Bits>::fast   fast;

-    BOOST_STATIC_CONSTANT( least, sig_bits = (~( ~(least( 0u )) << Bits )) );
+    BOOST_STATIC_CONSTANT( least, sig_bits = least(~(least(~(least( 0u ))) << Bits )) );
    BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) );

    BOOST_STATIC_CONSTANT( std::size_t, bit_count = Bits );

 };  // boost::low_bits_mask_t

+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif

 #define BOOST_LOW_BITS_MASK_SPECIALIZE( Type )                                  \
  template <  >  struct low_bits_mask_t< std::numeric_limits<Type>::digits >  { \
--- a/include/boost/integer/static_log2.hpp
+++ b/include/boost/integer/static_log2.hpp
@@ -10,11 +10,6 @@
 //
 //         ---------------------------------------------------
 //       See http://www.boost.org/libs/integer for documentation.
-
-//! \file
-//! \brief Compile-time calculation of integer part of the logarithm, in base 2, of a given number.
-//! \note For a run-time calculation of log2, see function integer_log2 at integer_log2.hpp.
-
 // ------------------------------------------------------------------------- //


@@ -25,8 +20,6 @@

 namespace boost {

-  //! \cond DETAIL
-
 namespace detail {

     namespace static_log2_impl {
@@ -106,7 +99,8 @@ namespace boost {

     }
 } // detail
-//! \endcond  // DETAIL
+
+

 // --------------------------------------
 // static_log2<x>
@@ -126,7 +120,7 @@ namespace boost {
 template <>
 struct static_log2<0> { };

-} // namespace boost
+}



--- a/include/boost/integer/static_min_max.hpp
+++ b/include/boost/integer/static_min_max.hpp
@@ -5,9 +5,7 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)

-//  See http://www.boost.org for updates, documentation, and revision history.
-//! \file
-//! \brief Compile-time evaluation of extrema: minimum or maximum of two values, signed or unsigned.
+//  See http://www.boost.org for updates, documentation, and revision history. 

 #ifndef BOOST_INTEGER_STATIC_MIN_MAX_HPP
 #define BOOST_INTEGER_STATIC_MIN_MAX_HPP
--- a/include/boost/integer_fwd.hpp
+++ b/include/boost/integer_fwd.hpp
@@ -5,8 +5,6 @@
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

 //  See http://www.boost.org/libs/integer for documentation.
-//! \file
-//! \brief Include all Boost.Integer files.

 #ifndef BOOST_INTEGER_FWD_HPP
 #define BOOST_INTEGER_FWD_HPP
@@ -18,6 +16,7 @@
 #include <boost/limits.hpp>  // for std::numeric_limits
 #include <boost/cstdint.hpp>  // For intmax_t

+
 namespace boost
 {

@@ -159,9 +158,9 @@ template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Valu
 template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
    struct static_unsigned_max;

+
 namespace integer
 {
-
 //  From <boost/integer/common_factor_ct.hpp>

 #ifdef BOOST_NO_INTEGRAL_INT64_T
@@ -183,7 +182,7 @@ template < typename IntegerType >
 template < typename IntegerType >
    class lcm_evaluator;

-] // namespace integer
+} // namespace integer

 }  // namespace boost

--- a/include/boost/integer_traits.hpp
+++ b/include/boost/integer_traits.hpp
@@ -8,15 +8,10 @@
 * $Id$
 *
 * Idea by Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers
-
 */

 //  See http://www.boost.org/libs/integer for documentation.

-//! \file
-//! \brief integer traits
-//! \sa http://www.boost.org/libs/integer
-

 #ifndef BOOST_INTEGER_TRAITS_HPP
 #define BOOST_INTEGER_TRAITS_HPP
@@ -52,7 +47,6 @@ public:
  BOOST_STATIC_CONSTANT(bool, is_integral = false);
 };

-//! \cond DETAIL
 namespace detail {
 template<class T, T min_val, T max_val>
 class integer_traits_base
@@ -76,7 +70,6 @@ const T integer_traits_base<T, min_val, max_val>::const_max;
 #endif

 } // namespace detail
-//! \endcond // DETAIL

 template<>
 class integer_traits<bool>
--- a/include/boost/pending/integer_log2.hpp
+++ b/include/boost/pending/integer_log2.hpp
@@ -1,9 +1,9 @@
 #ifndef BOOST_PENDING_INTEGER_LOG2_HPP
 #define BOOST_PENDING_INTEGER_LOG2_HPP

-// The header file at this path is deprecated;
-// use boost/integer/integer_log2.hpp instead.
-
 #include <boost/integer/integer_log2.hpp>
+#include <boost/config/header_deprecated.hpp>
+
+BOOST_HEADER_DEPRECATED("<boost/integer/integer_log2.hpp>");

 #endif
--- a/meta/libraries.json
+++ b/meta/libraries.json
@@ -7,6 +7,7 @@
    ],
    "authors": "",
    "maintainers": [
-        "Daryle Walker <darylew -at- hotmail.com>"
+        "Daryle Walker <darylew -at- hotmail.com>",
+        "Andrey Semashev <andrey.semashev -at- gmail.com>"
    ]
 }
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -6,8 +6,11 @@ import testing ;

 project : requirements <warnings>all <toolset>gcc:<cxxflags>-Wextra ;

+obj has_gmpxx : has_gmpxx.cpp ;
+explicit has_gmpxx ;
+
 test-suite integer
-    : 
+    :
        [ run integer_traits_test.cpp ]
        [ run integer_test.cpp : : : <toolset>gcc:<cxxflags>-Wno-long-long <toolset>darwin:<cxxflags>-Wno-long-long <toolset>sun:<cxxflags>"-Qoption ccfe -tmpldepth=128" ]
        [ run integer_mask_test.cpp ]
@@ -19,11 +22,14 @@ test-suite integer
        [ compile static_log2_include_test.cpp ]
        [ compile static_min_max_include_test.cpp ]
        [ compile integer_fwd_include_test.cpp ]
+        [ compile gcd_constexpr14_test.cpp ]
+        [ compile gcd_noexcept_test.cpp ]
        [ compile-fail fail_int_exact.cpp ]
        [ compile-fail fail_int_fast.cpp ]
        [ compile-fail fail_int_least.cpp ]
        [ compile-fail fail_uint_exact.cpp ]
        [ compile-fail fail_uint_fast.cpp ]
        [ compile-fail fail_uint_least.cpp ]
-        [ run common_factor_test.cpp ]
+        [ compile-fail fail_uint_65.cpp ]
+        [ run common_factor_test.cpp : : : [ check-target-builds has_gmpxx "Checking for gmpxx.h" : <define>BOOST_INTEGER_HAS_GMPXX_H=1 <linkflags>-lgmp <linkflags>-lgmpxx ] ]
    ;
--- a/test/common_factor_test.cpp
+++ b/test/common_factor_test.cpp
@@ -15,19 +15,34 @@
 //  02 Nov 2006  Change to Boost.Test's unit test system (Daryle Walker)
 //  07 Nov 2001  Initial version (Daryle Walker)

-#define BOOST_TEST_MAIN  "Boost.Math GCD & LCM unit tests"
+#define BOOST_TEST_MAIN  "Boost.integer GCD & LCM unit tests"

-#include <boost/integer/common_factor.hpp>
-
-#include <boost/config.hpp>                // for BOOST_MSVC, etc.
+#include <boost/config.hpp>              // for BOOST_MSVC, etc.
 #include <boost/detail/workaround.hpp>
+#include <boost/integer/common_factor.hpp>  // for boost::integer::gcd, etc.
+#include <boost/mpl/list.hpp>            // for boost::mpl::list
 #include <boost/operators.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <boost/random.hpp>
+#include <boost/rational.hpp>

 #include <istream>  // for std::basic_istream
 #include <limits>   // for std::numeric_limits
 #include <ostream>  // for std::basic_ostream

+#ifdef BOOST_INTEGER_HAS_GMPXX_H
+#include <gmpxx.h>
+#endif
+
+#if (defined(BOOST_MSVC) && (BOOST_MSVC < 1500)) || \
+    (defined(__clang_major__) && (__clang_major__ == 3) && (__clang_minor__ < 2)) || \
+    (defined(BOOST_GCC) && defined(BOOST_GCC_CXX11) && BOOST_GCC < 40800)
+#define DISABLE_MP_TESTS
+#endif
+
+#ifndef DISABLE_MP_TESTS
+#include <boost/multiprecision/cpp_int.hpp>
+#endif

 namespace {

@@ -109,6 +124,29 @@ MyUnsigned1  dummy2;
 MyInt2       dummy3;
 MyUnsigned2  dummy4;

+// Various types to test with each GCD/LCM
+typedef ::boost::mpl::list<signed char, short, int, long,
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1500)
+#elif defined(BOOST_HAS_LONG_LONG)
+ boost::long_long_type,
+#elif defined(BOOST_HAS_MS_INT64)
+ __int64,
+#endif
+ MyInt1
+#ifndef DISABLE_MP_TESTS
+   , boost::multiprecision::cpp_int
+#endif
+>  signed_test_types;
+typedef ::boost::mpl::list<unsigned char, unsigned short, unsigned,
+ unsigned long,
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1500)
+#elif defined(BOOST_HAS_LONG_LONG)
+ boost::ulong_long_type,
+#elif defined(BOOST_HAS_MS_INT64)
+ unsigned __int64,
+#endif
+ MyUnsigned1, MyUnsigned2 /*, boost::multiprecision::uint256_t*/>  unsigned_test_types;
+
 }  // namespace

 #define BOOST_NO_MACRO_EXPAND /**/
@@ -246,199 +284,321 @@ inline ostream& operator<<(ostream& os, unsigned __int64 i)
 // GCD on signed integer types
 template< class T > void gcd_int_test() // signed_test_types
 {
+#ifndef BOOST_MSVC
    using boost::integer::gcd;
+    using boost::integer::gcd_evaluator;
+#else
+    using namespace boost::integer;
+#endif

    // Originally from Boost.Rational tests
-    BOOST_TEST_EQ( gcd<T>(  1,  -1), static_cast<T>( 1) );
-    BOOST_TEST_EQ( gcd<T>( -1,   1), static_cast<T>( 1) );
-    BOOST_TEST_EQ( gcd<T>(  1,   1), static_cast<T>( 1) );
-    BOOST_TEST_EQ( gcd<T>( -1,  -1), static_cast<T>( 1) );
-    BOOST_TEST_EQ( gcd<T>(  0,   0), static_cast<T>( 0) );
-    BOOST_TEST_EQ( gcd<T>(  7,   0), static_cast<T>( 7) );
-    BOOST_TEST_EQ( gcd<T>(  0,   9), static_cast<T>( 9) );
-    BOOST_TEST_EQ( gcd<T>( -7,   0), static_cast<T>( 7) );
-    BOOST_TEST_EQ( gcd<T>(  0,  -9), static_cast<T>( 9) );
-    BOOST_TEST_EQ( gcd<T>( 42,  30), static_cast<T>( 6) );
-    BOOST_TEST_EQ( gcd<T>(  6,  -9), static_cast<T>( 3) );
-    BOOST_TEST_EQ( gcd<T>(-10, -10), static_cast<T>(10) );
-    BOOST_TEST_EQ( gcd<T>(-25, -10), static_cast<T>( 5) );
-    BOOST_TEST_EQ( gcd<T>(  3,   7), static_cast<T>( 1) );
-    BOOST_TEST_EQ( gcd<T>(  8,   9), static_cast<T>( 1) );
-    BOOST_TEST_EQ( gcd<T>(  7,  49), static_cast<T>( 7) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(1), static_cast<T>(-1)), static_cast<T>( 1) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(-1), static_cast<T>(1)), static_cast<T>( 1) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(1), static_cast<T>(1)), static_cast<T>( 1) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(-1), static_cast<T>(-1)), static_cast<T>( 1) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(0), static_cast<T>(0)), static_cast<T>( 0) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(7), static_cast<T>(0)), static_cast<T>( 7) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(0), static_cast<T>(9)), static_cast<T>( 9) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(-7), static_cast<T>(0)), static_cast<T>( 7) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(0), static_cast<T>(-9)), static_cast<T>( 9) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(42), static_cast<T>(30)), static_cast<T>( 6) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(6), static_cast<T>(-9)), static_cast<T>( 3) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(-10), static_cast<T>(-10)), static_cast<T>(10) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(-25), static_cast<T>(-10)), static_cast<T>( 5) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(3), static_cast<T>(7)), static_cast<T>( 1) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(8), static_cast<T>(9)), static_cast<T>( 1) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(7), static_cast<T>(49)), static_cast<T>( 7) );
+    // Again with function object:
+    BOOST_TEST_EQ(gcd_evaluator<T>()(1, -1), static_cast<T>(1));
+    BOOST_TEST_EQ(gcd_evaluator<T>()(-1, 1), static_cast<T>(1));
+    BOOST_TEST_EQ(gcd_evaluator<T>()(1, 1), static_cast<T>(1));
+    BOOST_TEST_EQ(gcd_evaluator<T>()(-1, -1), static_cast<T>(1));
+    BOOST_TEST_EQ(gcd_evaluator<T>()(0, 0), static_cast<T>(0));
+    BOOST_TEST_EQ(gcd_evaluator<T>()(7, 0), static_cast<T>(7));
+    BOOST_TEST_EQ(gcd_evaluator<T>()(0, 9), static_cast<T>(9));
+    BOOST_TEST_EQ(gcd_evaluator<T>()(-7, 0), static_cast<T>(7));
+    BOOST_TEST_EQ(gcd_evaluator<T>()(0, -9), static_cast<T>(9));
+    BOOST_TEST_EQ(gcd_evaluator<T>()(42, 30), static_cast<T>(6));
+    BOOST_TEST_EQ(gcd_evaluator<T>()(6, -9), static_cast<T>(3));
+    BOOST_TEST_EQ(gcd_evaluator<T>()(-10, -10), static_cast<T>(10));
+    BOOST_TEST_EQ(gcd_evaluator<T>()(-25, -10), static_cast<T>(5));
+    BOOST_TEST_EQ(gcd_evaluator<T>()(3, 7), static_cast<T>(1));
+    BOOST_TEST_EQ(gcd_evaluator<T>()(8, 9), static_cast<T>(1));
+    BOOST_TEST_EQ(gcd_evaluator<T>()(7, 49), static_cast<T>(7));
 }

 // GCD on unmarked signed integer type
 void gcd_unmarked_int_test()
 {
+#ifndef BOOST_MSVC
    using boost::integer::gcd;
+#else
+    using namespace boost::integer;
+#endif

    // The regular signed-integer GCD function performs the unsigned version,
    // then does an absolute-value on the result.  Signed types that are not
    // marked as such (due to no std::numeric_limits specialization) may be off
    // by a sign.
-    BOOST_TEST_EQ( abs(gcd<MyInt2>(   1,  -1 )), MyInt2( 1) );
-    BOOST_TEST_EQ( abs(gcd<MyInt2>(  -1,   1 )), MyInt2( 1) );
-    BOOST_TEST_EQ( abs(gcd<MyInt2>(   1,   1 )), MyInt2( 1) );
-    BOOST_TEST_EQ( abs(gcd<MyInt2>(  -1,  -1 )), MyInt2( 1) );
-    BOOST_TEST_EQ( abs(gcd<MyInt2>(   0,   0 )), MyInt2( 0) );
-    BOOST_TEST_EQ( abs(gcd<MyInt2>(   7,   0 )), MyInt2( 7) );
-    BOOST_TEST_EQ( abs(gcd<MyInt2>(   0,   9 )), MyInt2( 9) );
-    BOOST_TEST_EQ( abs(gcd<MyInt2>(  -7,   0 )), MyInt2( 7) );
-    BOOST_TEST_EQ( abs(gcd<MyInt2>(   0,  -9 )), MyInt2( 9) );
-    BOOST_TEST_EQ( abs(gcd<MyInt2>(  42,  30 )), MyInt2( 6) );
-    BOOST_TEST_EQ( abs(gcd<MyInt2>(   6,  -9 )), MyInt2( 3) );
-    BOOST_TEST_EQ( abs(gcd<MyInt2>( -10, -10 )), MyInt2(10) );
-    BOOST_TEST_EQ( abs(gcd<MyInt2>( -25, -10 )), MyInt2( 5) );
-    BOOST_TEST_EQ( abs(gcd<MyInt2>(   3,   7 )), MyInt2( 1) );
-    BOOST_TEST_EQ( abs(gcd<MyInt2>(   8,   9 )), MyInt2( 1) );
-    BOOST_TEST_EQ( abs(gcd<MyInt2>(   7,  49 )), MyInt2( 7) );
+    BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(1), static_cast<MyInt2>(-1) )), MyInt2( 1) );
+    BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(-1), static_cast<MyInt2>(1) )), MyInt2( 1) );
+    BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(1), static_cast<MyInt2>(1) )), MyInt2( 1) );
+    BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(-1), static_cast<MyInt2>(-1) )), MyInt2( 1) );
+    BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(0), static_cast<MyInt2>(0) )), MyInt2( 0) );
+    BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(7), static_cast<MyInt2>(0) )), MyInt2( 7) );
+    BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(0), static_cast<MyInt2>(9) )), MyInt2( 9) );
+    BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(-7), static_cast<MyInt2>(0) )), MyInt2( 7) );
+    BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(0), static_cast<MyInt2>(-9) )), MyInt2( 9) );
+    BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(42), static_cast<MyInt2>(30))), MyInt2( 6) );
+    BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(6), static_cast<MyInt2>(-9) )), MyInt2( 3) );
+    BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(-10), static_cast<MyInt2>(-10) )), MyInt2(10) );
+    BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(-25), static_cast<MyInt2>(-10) )), MyInt2( 5) );
+    BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(3), static_cast<MyInt2>(7) )), MyInt2( 1) );
+    BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(8), static_cast<MyInt2>(9) )), MyInt2( 1) );
+    BOOST_TEST_EQ( abs(boost::integer::gcd(static_cast<MyInt2>(7), static_cast<MyInt2>(49) )), MyInt2( 7) );
 }

 // GCD on unsigned integer types
 template< class T > void gcd_unsigned_test() // unsigned_test_types
 {
+#ifndef BOOST_MSVC
    using boost::integer::gcd;
+#else
+    using namespace boost::integer;
+#endif

    // Note that unmarked types (i.e. have no std::numeric_limits
    // specialization) are treated like non/unsigned types
-    BOOST_TEST_EQ( gcd<T>( 1u,   1u), static_cast<T>( 1u) );
-    BOOST_TEST_EQ( gcd<T>( 0u,   0u), static_cast<T>( 0u) );
-    BOOST_TEST_EQ( gcd<T>( 7u,   0u), static_cast<T>( 7u) );
-    BOOST_TEST_EQ( gcd<T>( 0u,   9u), static_cast<T>( 9u) );
-    BOOST_TEST_EQ( gcd<T>(42u,  30u), static_cast<T>( 6u) );
-    BOOST_TEST_EQ( gcd<T>( 3u,   7u), static_cast<T>( 1u) );
-    BOOST_TEST_EQ( gcd<T>( 8u,   9u), static_cast<T>( 1u) );
-    BOOST_TEST_EQ( gcd<T>( 7u,  49u), static_cast<T>( 7u) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(1u), static_cast<T>(1u)), static_cast<T>( 1u) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(0u), static_cast<T>(0u)), static_cast<T>( 0u) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(7u), static_cast<T>(0u)), static_cast<T>( 7u) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(0u), static_cast<T>(9u)), static_cast<T>( 9u) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(42u), static_cast<T>(30u)), static_cast<T>( 6u) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(3u), static_cast<T>(7u)), static_cast<T>( 1u) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(8u), static_cast<T>(9u)), static_cast<T>( 1u) );
+    BOOST_TEST_EQ( boost::integer::gcd(static_cast<T>(7u), static_cast<T>(49u)), static_cast<T>( 7u) );
 }

 // GCD at compile-time
 void gcd_static_test()
 {
+#ifndef BOOST_MSVC
    using boost::integer::static_gcd;
+#else
+    using namespace boost::integer;
+#endif

-    BOOST_TEST_EQ( (static_gcd< 1,  1>::value), 1 );
-    BOOST_TEST_EQ( (static_gcd< 0,  0>::value), 0 );
-    BOOST_TEST_EQ( (static_gcd< 7,  0>::value), 7 );
-    BOOST_TEST_EQ( (static_gcd< 0,  9>::value), 9 );
-    BOOST_TEST_EQ( (static_gcd<42, 30>::value), 6 );
-    BOOST_TEST_EQ( (static_gcd< 3,  7>::value), 1 );
-    BOOST_TEST_EQ( (static_gcd< 8,  9>::value), 1 );
-    BOOST_TEST_EQ( (static_gcd< 7, 49>::value), 7 );
+    // Can't use "BOOST_TEST_EQ", otherwise the "value" member will be
+    // disqualified as compile-time-only constant, needing explicit definition
+    BOOST_TEST( (static_gcd< 1,  1>::value) == 1 );
+    BOOST_TEST( (static_gcd< 0,  0>::value) == 0 );
+    BOOST_TEST( (static_gcd< 7,  0>::value) == 7 );
+    BOOST_TEST( (static_gcd< 0,  9>::value) == 9 );
+    BOOST_TEST( (static_gcd<42, 30>::value) == 6 );
+    BOOST_TEST( (static_gcd< 3,  7>::value) == 1 );
+    BOOST_TEST( (static_gcd< 8,  9>::value) == 1 );
+    BOOST_TEST( (static_gcd< 7, 49>::value) == 7 );
 }

-// TODO: non-built-in signed and unsigned integer tests, with and without
-// numeric_limits specialization; polynominal tests; note any changes if
-// built-ins switch to binary-GCD algorithm
+void gcd_method_test()
+{
+   // Verify that the 3 different methods all yield the same result:
+   boost::random::mt19937 gen;
+   boost::random::uniform_int_distribution<int> d(0, ((std::numeric_limits<int>::max)() / 2));

+   for (unsigned int i = 0; i < 10000; ++i)
+   {
+      int v1 = d(gen);
+      int v2 = d(gen);
+      int g = boost::integer::gcd_detail::Euclid_gcd(v1, v2);
+      BOOST_TEST(v1 % g == 0);
+      BOOST_TEST(v2 % g == 0);
+      BOOST_TEST_EQ(g, boost::integer::gcd_detail::mixed_binary_gcd(v1, v2));
+      BOOST_TEST_EQ(g, boost::integer::gcd_detail::Stein_gcd(v1, v2));
+   }
+}

 // LCM tests

 // LCM on signed integer types
 template< class T > void lcm_int_test() // signed_test_types
 {
+#ifndef BOOST_MSVC
    using boost::integer::lcm;
+    using boost::integer::lcm_evaluator;
+#else
+    using namespace boost::integer;
+#endif

    // Originally from Boost.Rational tests
-    BOOST_TEST_EQ( lcm<T>(  1,  -1), static_cast<T>( 1) );
-    BOOST_TEST_EQ( lcm<T>( -1,   1), static_cast<T>( 1) );
-    BOOST_TEST_EQ( lcm<T>(  1,   1), static_cast<T>( 1) );
-    BOOST_TEST_EQ( lcm<T>( -1,  -1), static_cast<T>( 1) );
-    BOOST_TEST_EQ( lcm<T>(  0,   0), static_cast<T>( 0) );
-    BOOST_TEST_EQ( lcm<T>(  6,   0), static_cast<T>( 0) );
-    BOOST_TEST_EQ( lcm<T>(  0,   7), static_cast<T>( 0) );
-    BOOST_TEST_EQ( lcm<T>( -5,   0), static_cast<T>( 0) );
-    BOOST_TEST_EQ( lcm<T>(  0,  -4), static_cast<T>( 0) );
-    BOOST_TEST_EQ( lcm<T>( 18,  30), static_cast<T>(90) );
-    BOOST_TEST_EQ( lcm<T>( -6,   9), static_cast<T>(18) );
-    BOOST_TEST_EQ( lcm<T>(-10, -10), static_cast<T>(10) );
-    BOOST_TEST_EQ( lcm<T>( 25, -10), static_cast<T>(50) );
-    BOOST_TEST_EQ( lcm<T>(  3,   7), static_cast<T>(21) );
-    BOOST_TEST_EQ( lcm<T>(  8,   9), static_cast<T>(72) );
-    BOOST_TEST_EQ( lcm<T>(  7,  49), static_cast<T>(49) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(1), static_cast<T>(-1)), static_cast<T>( 1) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(-1), static_cast<T>(1)), static_cast<T>( 1) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(1), static_cast<T>(1)), static_cast<T>( 1) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(-1), static_cast<T>(-1)), static_cast<T>( 1) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(0), static_cast<T>(0)), static_cast<T>( 0) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(6), static_cast<T>(0)), static_cast<T>( 0) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(0), static_cast<T>(7)), static_cast<T>( 0) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(-5), static_cast<T>(0)), static_cast<T>( 0) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(0), static_cast<T>(-4)), static_cast<T>( 0) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(18), static_cast<T>(30)), static_cast<T>(90) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(-6), static_cast<T>(9)), static_cast<T>(18) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(-10), static_cast<T>(-10)), static_cast<T>(10) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(25), static_cast<T>(-10)), static_cast<T>(50) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(3), static_cast<T>(7)), static_cast<T>(21) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(8), static_cast<T>(9)), static_cast<T>(72) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(7), static_cast<T>(49)), static_cast<T>(49) );
+    // Again with function object:
+    BOOST_TEST_EQ(lcm_evaluator<T>()(1, -1), static_cast<T>(1));
+    BOOST_TEST_EQ(lcm_evaluator<T>()(-1, 1), static_cast<T>(1));
+    BOOST_TEST_EQ(lcm_evaluator<T>()(1, 1), static_cast<T>(1));
+    BOOST_TEST_EQ(lcm_evaluator<T>()(-1, -1), static_cast<T>(1));
+    BOOST_TEST_EQ(lcm_evaluator<T>()(0, 0), static_cast<T>(0));
+    BOOST_TEST_EQ(lcm_evaluator<T>()(6, 0), static_cast<T>(0));
+    BOOST_TEST_EQ(lcm_evaluator<T>()(0, 7), static_cast<T>(0));
+    BOOST_TEST_EQ(lcm_evaluator<T>()(-5, 0), static_cast<T>(0));
+    BOOST_TEST_EQ(lcm_evaluator<T>()(0, -4), static_cast<T>(0));
+    BOOST_TEST_EQ(lcm_evaluator<T>()(18, 30), static_cast<T>(90));
+    BOOST_TEST_EQ(lcm_evaluator<T>()(-6, 9), static_cast<T>(18));
+    BOOST_TEST_EQ(lcm_evaluator<T>()(-10, -10), static_cast<T>(10));
+    BOOST_TEST_EQ(lcm_evaluator<T>()(25, -10), static_cast<T>(50));
+    BOOST_TEST_EQ(lcm_evaluator<T>()(3, 7), static_cast<T>(21));
+    BOOST_TEST_EQ(lcm_evaluator<T>()(8, 9), static_cast<T>(72));
+    BOOST_TEST_EQ(lcm_evaluator<T>()(7, 49), static_cast<T>(49));
 }

 // LCM on unmarked signed integer type
 void lcm_unmarked_int_test()
 {
+#ifndef BOOST_MSVC
    using boost::integer::lcm;
+#else
+    using namespace boost::integer;
+#endif

    // The regular signed-integer LCM function performs the unsigned version,
    // then does an absolute-value on the result.  Signed types that are not
    // marked as such (due to no std::numeric_limits specialization) may be off
    // by a sign.
-    BOOST_TEST_EQ( abs(lcm<MyInt2>(   1,  -1 )), MyInt2( 1) );
-    BOOST_TEST_EQ( abs(lcm<MyInt2>(  -1,   1 )), MyInt2( 1) );
-    BOOST_TEST_EQ( abs(lcm<MyInt2>(   1,   1 )), MyInt2( 1) );
-    BOOST_TEST_EQ( abs(lcm<MyInt2>(  -1,  -1 )), MyInt2( 1) );
-    BOOST_TEST_EQ( abs(lcm<MyInt2>(   0,   0 )), MyInt2( 0) );
-    BOOST_TEST_EQ( abs(lcm<MyInt2>(   6,   0 )), MyInt2( 0) );
-    BOOST_TEST_EQ( abs(lcm<MyInt2>(   0,   7 )), MyInt2( 0) );
-    BOOST_TEST_EQ( abs(lcm<MyInt2>(  -5,   0 )), MyInt2( 0) );
-    BOOST_TEST_EQ( abs(lcm<MyInt2>(   0,  -4 )), MyInt2( 0) );
-    BOOST_TEST_EQ( abs(lcm<MyInt2>(  18,  30 )), MyInt2(90) );
-    BOOST_TEST_EQ( abs(lcm<MyInt2>(  -6,   9 )), MyInt2(18) );
-    BOOST_TEST_EQ( abs(lcm<MyInt2>( -10, -10 )), MyInt2(10) );
-    BOOST_TEST_EQ( abs(lcm<MyInt2>(  25, -10 )), MyInt2(50) );
-    BOOST_TEST_EQ( abs(lcm<MyInt2>(   3,   7 )), MyInt2(21) );
-    BOOST_TEST_EQ( abs(lcm<MyInt2>(   8,   9 )), MyInt2(72) );
-    BOOST_TEST_EQ( abs(lcm<MyInt2>(   7,  49 )), MyInt2(49) );
+    BOOST_TEST_EQ( abs(boost::integer::lcm(   static_cast<MyInt2>(1), static_cast<MyInt2>(-1) )), MyInt2( 1) );
+    BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(-1), static_cast<MyInt2>(1) )), MyInt2( 1) );
+    BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(1), static_cast<MyInt2>(1) )), MyInt2( 1) );
+    BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(-1), static_cast<MyInt2>(-1) )), MyInt2( 1) );
+    BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(0), static_cast<MyInt2>(0) )), MyInt2( 0) );
+    BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(6), static_cast<MyInt2>(0) )), MyInt2( 0) );
+    BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(0), static_cast<MyInt2>(7) )), MyInt2( 0) );
+    BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(-5), static_cast<MyInt2>(0) )), MyInt2( 0) );
+    BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(0), static_cast<MyInt2>(-4) )), MyInt2( 0) );
+    BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(18), static_cast<MyInt2>(30) )), MyInt2(90) );
+    BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(-6), static_cast<MyInt2>(9) )), MyInt2(18) );
+    BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(-10), static_cast<MyInt2>(-10) )), MyInt2(10) );
+    BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(25), static_cast<MyInt2>(-10) )), MyInt2(50) );
+    BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(3), static_cast<MyInt2>(7) )), MyInt2(21) );
+    BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(8), static_cast<MyInt2>(9) )), MyInt2(72) );
+    BOOST_TEST_EQ( abs(boost::integer::lcm(static_cast<MyInt2>(7), static_cast<MyInt2>(49) )), MyInt2(49) );
 }

 // LCM on unsigned integer types
 template< class T > void lcm_unsigned_test() // unsigned_test_types
 {
+#ifndef BOOST_MSVC
    using boost::integer::lcm;
+#else
+    using namespace boost::integer;
+#endif

    // Note that unmarked types (i.e. have no std::numeric_limits
    // specialization) are treated like non/unsigned types
-    BOOST_TEST_EQ( lcm<T>( 1u,   1u), static_cast<T>( 1u) );
-    BOOST_TEST_EQ( lcm<T>( 0u,   0u), static_cast<T>( 0u) );
-    BOOST_TEST_EQ( lcm<T>( 6u,   0u), static_cast<T>( 0u) );
-    BOOST_TEST_EQ( lcm<T>( 0u,   7u), static_cast<T>( 0u) );
-    BOOST_TEST_EQ( lcm<T>(18u,  30u), static_cast<T>(90u) );
-    BOOST_TEST_EQ( lcm<T>( 3u,   7u), static_cast<T>(21u) );
-    BOOST_TEST_EQ( lcm<T>( 8u,   9u), static_cast<T>(72u) );
-    BOOST_TEST_EQ( lcm<T>( 7u,  49u), static_cast<T>(49u) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(1u), static_cast<T>(1u)), static_cast<T>( 1u) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(0u), static_cast<T>(0u)), static_cast<T>( 0u) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(6u), static_cast<T>(0u)), static_cast<T>( 0u) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(0u), static_cast<T>(7u)), static_cast<T>( 0u) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(18u), static_cast<T>(30u)), static_cast<T>(90u) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(3u), static_cast<T>(7u)), static_cast<T>(21u) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(8u), static_cast<T>(9u)), static_cast<T>(72u) );
+    BOOST_TEST_EQ( boost::integer::lcm(static_cast<T>(7u), static_cast<T>(49u)), static_cast<T>(49u) );
 }

 // LCM at compile-time
 void lcm_static_test()
 {
+#ifndef BOOST_MSVC
    using boost::integer::static_lcm;
+#else
+    using namespace boost::integer;
+#endif

-    BOOST_TEST_EQ( (static_lcm< 1,  1>::value),  1 );
-    BOOST_TEST_EQ( (static_lcm< 0,  0>::value),  0 );
-    BOOST_TEST_EQ( (static_lcm< 6,  0>::value),  0 );
-    BOOST_TEST_EQ( (static_lcm< 0,  7>::value),  0 );
-    BOOST_TEST_EQ( (static_lcm<18, 30>::value), 90 );
-    BOOST_TEST_EQ( (static_lcm< 3,  7>::value), 21 );
-    BOOST_TEST_EQ( (static_lcm< 8,  9>::value), 72 );
-    BOOST_TEST_EQ( (static_lcm< 7, 49>::value), 49 );
+    // Can't use "BOOST_TEST_EQ", otherwise the "value" member will be
+    // disqualified as compile-time-only constant, needing explicit definition
+    BOOST_TEST( (static_lcm< 1,  1>::value) ==  1 );
+    BOOST_TEST( (static_lcm< 0,  0>::value) ==  0 );
+    BOOST_TEST( (static_lcm< 6,  0>::value) ==  0 );
+    BOOST_TEST( (static_lcm< 0,  7>::value) ==  0 );
+    BOOST_TEST( (static_lcm<18, 30>::value) == 90 );
+    BOOST_TEST( (static_lcm< 3,  7>::value) == 21 );
+    BOOST_TEST( (static_lcm< 8,  9>::value) == 72 );
+    BOOST_TEST( (static_lcm< 7, 49>::value) == 49 );
 }

-// TODO: see GCD to-do
+void variadics()
+{
+   unsigned i[] = { 44, 56, 76, 88 };
+   BOOST_TEST_EQ(boost::integer::gcd_range(i, i + 4).first, 4);
+   BOOST_TEST_EQ(boost::integer::gcd_range(i, i + 4).second, i + 4);
+   BOOST_TEST_EQ(boost::integer::lcm_range(i, i + 4).first, 11704);
+   BOOST_TEST_EQ(boost::integer::lcm_range(i, i + 4).second, i + 4);
+#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+   BOOST_TEST_EQ(boost::integer::gcd(i[0], i[1], i[2], i[3]), 4);
+   BOOST_TEST_EQ(boost::integer::lcm(i[0], i[1], i[2], i[3]), 11704);
+#endif
+}

-// main
-
-// Various types to test with each GCD/LCM
+// Test case from Boost.Rational, need to make sure we don't break the rational lib:
+template <class T> void gcd_and_lcm_on_rationals()
+{
+   typedef boost::rational<T> rational;
+   BOOST_TEST_EQ(boost::integer::gcd(rational(1, 4), rational(1, 3)),
+      rational(1, 12));
+   BOOST_TEST_EQ(boost::integer::lcm(rational(1, 4), rational(1, 3)),
+      rational(1));
+}

+#ifndef DISABLE_MP_TESTS
+#define TEST_SIGNED_( test ) \
+    test<signed char>(); \
+    test<short>(); \
+    test<int>(); \
+    test<long>(); \
+    test<MyInt1>(); \
+    test<boost::multiprecision::cpp_int>(); \
+    test<boost::multiprecision::int512_t>();
+#else
 #define TEST_SIGNED_( test ) \
    test<signed char>(); \
    test<short>(); \
    test<int>(); \
    test<long>(); \
    test<MyInt1>();
+#endif

 #ifdef BOOST_HAS_LONG_LONG
-# define TEST_SIGNED( test ) \
+# define TEST_SIGNED__( test ) \
    TEST_SIGNED_( test ) \
    test<boost::long_long_type>();
 #elif defined(BOOST_HAS_MS_INT64)
-# define TEST_SIGNED( test ) \
+# define TEST_SIGNED__( test ) \
    TEST_SIGNED_( test ) \
    test<__int64>();
 #endif
-
+#ifndef DISABLE_MP_TESTS
+#define TEST_UNSIGNED_( test ) \
+    test<unsigned char>(); \
+    test<unsigned short>(); \
+    test<unsigned>(); \
+    test<unsigned long>(); \
+    test<MyUnsigned1>(); \
+    test<MyUnsigned2>(); \
+    test<boost::multiprecision::uint512_t>();
+#else
 #define TEST_UNSIGNED_( test ) \
    test<unsigned char>(); \
    test<unsigned short>(); \
@@ -446,6 +606,7 @@ void lcm_static_test()
    test<unsigned long>(); \
    test<MyUnsigned1>(); \
    test<MyUnsigned2>();
+#endif

 #ifdef BOOST_HAS_LONG_LONG
 # define TEST_UNSIGNED( test ) \
@@ -457,17 +618,30 @@ void lcm_static_test()
    test<unsigned __int64>();
 #endif

+#ifdef BOOST_INTEGER_HAS_GMPXX_H
+#  define TEST_SIGNED(test)\
+      TEST_SIGNED__(test)\
+      test<mpz_class>();
+#  define TEST_SIGNED_NO_GMP(test) TEST_SIGNED__(test)
+#else
+#  define TEST_SIGNED(test) TEST_SIGNED__(test)
+#  define TEST_SIGNED_NO_GMP(test) TEST_SIGNED__(test)
+#endif
+
 int main()
 {
-    TEST_SIGNED( gcd_int_test )
-    gcd_unmarked_int_test();
-    TEST_UNSIGNED( gcd_unsigned_test )
-    gcd_static_test();
+   TEST_SIGNED(gcd_int_test)
+   gcd_unmarked_int_test();
+   TEST_UNSIGNED(gcd_unsigned_test)
+   gcd_static_test();
+   gcd_method_test();

-    TEST_SIGNED( lcm_int_test )
-    lcm_unmarked_int_test();
-    TEST_UNSIGNED( lcm_unsigned_test )
-    lcm_static_test();
+   TEST_SIGNED(lcm_int_test)
+   lcm_unmarked_int_test();
+   TEST_UNSIGNED(lcm_unsigned_test)
+   lcm_static_test();
+   variadics();
+   TEST_SIGNED_NO_GMP(gcd_and_lcm_on_rationals)

-    return boost::report_errors();
+   return boost::report_errors();
 }
--- a/test/fail_uint_65.cpp
+++ b/test/fail_uint_65.cpp
@@ -0,0 +1,13 @@
+//  Copyright John Maddock 2012.
+//  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)
+
+#include <boost/integer.hpp>
+#include <iostream>
+
+int main()
+{
+ std::cout << std::numeric_limits<boost::uint_t<65>::least>::digits;
+ return 0;
+}
--- a/test/gcd_constexpr14_test.cpp
+++ b/test/gcd_constexpr14_test.cpp
@@ -0,0 +1,66 @@
+
+//  (C) Copyright John Maddock 2017.
+//  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)
+
+#include <boost/integer/common_factor.hpp>
+
+#ifndef BOOST_NO_CXX14_CONSTEXPR
+
+void test_constexpr1()
+{
+   constexpr const boost::int64_t i = 347 * 463 * 727;
+   constexpr const boost::int64_t j = 191 * 347 * 281;
+
+   constexpr const boost::int64_t k = boost::integer::gcd(i, j);
+   constexpr const boost::int64_t l = boost::integer::lcm(i, j);
+
+   static_assert(k == 347, "Expected result not integer in constexpr gcd.");
+   static_assert(l == 6268802158037, "Expected result not integer in constexpr lcm.");
+}
+
+void test_constexpr2()
+{
+   constexpr const boost::uint64_t i = 347 * 463 * 727;
+   constexpr const boost::uint64_t j = 191 * 347 * 281;
+
+   constexpr const boost::uint64_t k = boost::integer::gcd(i, j);
+   constexpr const boost::uint64_t l = boost::integer::lcm(i, j);
+
+   static_assert(k == 347, "Expected result not integer in constexpr gcd.");
+   static_assert(l == 6268802158037, "Expected result not integer in constexpr lcm.");
+}
+
+void test_constexpr3()
+{
+   constexpr const boost::uint64_t i = 347 * 463 * 727;
+   constexpr const boost::uint64_t j = 191 * 347 * 281;
+
+   constexpr const boost::uint64_t k = boost::integer::gcd_detail::Euclid_gcd(i, j);
+
+   static_assert(k == 347, "Expected result not integer in constexpr gcd.");
+}
+
+void test_constexpr4()
+{
+   constexpr const boost::uint64_t i = 347 * 463 * 727;
+   constexpr const boost::uint64_t j = 191 * 347 * 281;
+
+   constexpr const boost::uint64_t k = boost::integer::gcd_detail::mixed_binary_gcd(i, j);
+
+   static_assert(k == 347, "Expected result not integer in constexpr gcd.");
+}
+
+void test_constexpr5()
+{
+   constexpr const boost::uint64_t i = 347 * 463 * 727;
+   constexpr const boost::uint64_t j = 191 * 347 * 281;
+
+   constexpr const boost::uint64_t k = boost::integer::gcd_detail::Stein_gcd(i, j);
+
+   static_assert(k == 347, "Expected result not integer in constexpr gcd.");
+}
+#endif
+
+
--- a/test/gcd_noexcept_test.cpp
+++ b/test/gcd_noexcept_test.cpp
@@ -0,0 +1,35 @@
+
+//  (C) Copyright John Maddock 2017.
+//  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)
+
+#include <boost/integer/common_factor.hpp>
+
+#if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+//
+// These tests don't pass with GCC-4.x:
+//
+#if !defined(BOOST_GCC) || (BOOST_GCC >= 50000)
+
+void test_noexcept(unsigned char a, unsigned char b)
+{
+   static_assert(noexcept(boost::integer::gcd(static_cast<unsigned char>(a), static_cast<unsigned char>(b))), "Expected a noexcept function.");
+#ifndef _MSC_VER
+   // This generates an internal compiler error if enabled as well as the following test:
+   static_assert(noexcept(boost::integer::gcd(static_cast<char>(a), static_cast<char>(b))), "Expected a noexcept function.");
+#endif
+   static_assert(noexcept(boost::integer::gcd(static_cast<signed char>(a), static_cast<signed char>(b))), "Expected a noexcept function.");
+   static_assert(noexcept(boost::integer::gcd(static_cast<short>(a), static_cast<short>(b))), "Expected a noexcept function.");
+   static_assert(noexcept(boost::integer::gcd(static_cast<unsigned short>(a), static_cast<unsigned short>(b))), "Expected a noexcept function.");
+   static_assert(noexcept(boost::integer::gcd(static_cast<int>(a), static_cast<int>(b))), "Expected a noexcept function.");
+   static_assert(noexcept(boost::integer::gcd(static_cast<unsigned int>(a), static_cast<unsigned int>(b))), "Expected a noexcept function.");
+   static_assert(noexcept(boost::integer::gcd(static_cast<long>(a), static_cast<long>(b))), "Expected a noexcept function.");
+   static_assert(noexcept(boost::integer::gcd(static_cast<unsigned long>(a), static_cast<unsigned long>(b))), "Expected a noexcept function.");
+   static_assert(noexcept(boost::integer::gcd(static_cast<long long>(a), static_cast<long long>(b))), "Expected a noexcept function.");
+   static_assert(noexcept(boost::integer::gcd(static_cast<unsigned long long>(a), static_cast<unsigned long long>(b))), "Expected a noexcept function.");
+}
+
+#endif
+#endif
+
--- a/test/has_gmpxx.cpp
+++ b/test/has_gmpxx.cpp
@@ -0,0 +1,15 @@
+//  Copyright John Maddock 2008.
+//  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)
+
+#include <gmpxx.h>
+
+// On Linux, libgmpxx is built with gcc and libstdc++. When the user application, such as tests, are built against libc++,
+// linking fails because of the C++ standard library symbol names mismatch. So fail the test if we're not using libstdc++.
+#if defined(__linux__) || defined(__linux) || defined(linux)
+#include <utility>
+#if !defined(__GLIBCPP__) && !defined(__GLIBCXX__)
+#error "libgmpxx is not supported on this platform with this C++ standard library"
+#endif
+#endif
--- a/test/integer_test.cpp
+++ b/test/integer_test.cpp
@@ -18,6 +18,7 @@
 #include <boost/detail/lightweight_test.hpp>  // for main, BOOST_TEST
 #include <boost/integer.hpp>  // for boost::int_t, boost::uint_t
 #include <boost/type_traits/is_same.hpp>
+#include <boost/mpl/bool.hpp> // for mpl::true_ and false_

 #include <climits>   // for ULONG_MAX, LONG_MAX, LONG_MIN
 #include <iostream>  // for std::cout (std::endl indirectly)
@@ -69,7 +70,7 @@ void do_test_exact(boost::mpl::true_ const&)
 template <int Bits>
 void do_test_exact(boost::mpl::false_ const&)
 {
-   // Nothing to do, type does not have an ::exact member.
+   // Nothing to do, type does not have an ::extact member.
 }

 template <int Bits>
Author	SHA1	Message	Date
Andrey Semashev	099cf261b0	Added clang 7 CI job.	2018-11-01 20:24:04 +03:00
Andrey Semashev	ab509ca840	Use https in URLs in readme.	2018-11-01 16:33:47 +03:00
Andrey Semashev	37204ea892	Corrected a typo in readme.	2018-11-01 16:25:15 +03:00
Andrey Semashev	5df4961448	Added CI build statuses to readme.	2018-11-01 16:14:20 +03:00
Andrey Semashev	95a19b6364	Merge pull request #14 from boostorg/danieljames-patch-1 Fix json error	2018-10-30 11:46:15 +03:00
Daniel James	8674c6724f	Fix json error	2018-10-30 07:47:30 +00:00
Andrey Semashev	7c5def9d39	Disable Boost.Multiprecision tests for gcc 4.7 in C++11 mode. The compiler fails in Boost.TypeTraits which is used in Boost.Multiprecision.	2018-10-29 12:25:55 +03:00
Andrey Semashev	791a139a51	Disable testing C++14 and 17 on clang 3.8 and 3.9. The compiler uses libstdc++ from gcc 4.8, which does not support C++14. In particular, it is trying to import the missing ::gets function.	2018-10-29 12:13:42 +03:00
Andrey Semashev	835ac98a23	Fail libgmpxx detection on Linux if libstdc++ is not used as the std library. libgmpxx was built against libstdc++, so if the application uses e.g. libc++, linking fails because of the standard symbols mismatch.	2018-10-29 12:07:06 +03:00
Andrey Semashev	b5d5c56e68	Use boostdep to install library dependencies.	2018-10-28 19:51:00 +03:00
Andrey Semashev	3961dc2f1e	Changed clang 3.9 toolset apt source to Trusty to fix compilation errors. Aggregated multiple C++ versions to CI jobs and added more toolsets.	2018-10-28 19:11:29 +03:00
Andrey Semashev	645edc971d	Added Boost.IO to CI checkout as it's required by Boost.Random.	2018-10-28 01:12:49 +03:00
Andrey Semashev	e00ffe97ae	Merge branch 'develop'	2018-10-27 20:26:07 +03:00
Andrey Semashev	1c586d6dd0	Merge pull request #13 from NAThompson/deprecate_pending_3 [ci skip] Deprecate boost/pending/integer_log2.hpp	2018-10-24 17:59:09 +03:00
Andrey Semashev	6a97e49614	Added a readme. Added myself as a maintainer.	2018-10-24 17:56:15 +03:00
Nick Thompson	661986dd3d	[ci skip] Deprecate boost/pending/integer_log2.hpp	2018-02-11 12:32:14 -06:00
Glen Fernandes	919c5277c1	Merge pull request #10 from Lastique/patch-2 Correct make_odd return type inconsistency	2017-08-27 12:07:50 -04:00
Andrey Semashev	bc2349f71b	Corrected make_odd return type inconsistency. Make gcd_traits<signed char>::make_odd return unsigned int, similar to all other gcd_traits specializations. Also, correct the local variable types that receive the result of make_odd to avoid warnings about unintended conversion.	2017-08-20 01:57:09 +03:00
jzmaddock	66dbc2c70a	Merge pull request #9 from boostorg/develop Merge develop to master	2017-06-10 08:29:02 +01:00
jzmaddock	10026d9b6f	Disable some tests on older compilers that we know won't pass.	2017-06-09 19:47:18 +01:00
jzmaddock	3e84cde165	Merge branch 'develop' of https://github.com/boostorg/integer into develop	2017-06-09 14:52:03 +01:00
jzmaddock	5c129565d5	CI: add missing appveyor dependency	2017-06-09 14:51:50 +01:00
jzmaddock	9a26557f38	Merge pull request #7 from DanielaE/fix/narrowing fix narrowing warnings due to integer promotion.	2017-06-08 19:25:00 +01:00
Daniela Engert	6ebccd6c80	fix narrowing warnings due to integer promotion. Signed-off-by: Daniela Engert <dani@ngrt.de>	2017-06-08 17:40:32 +02:00
jzmaddock	6662dbdbbd	CI: Fix appveyor bjam arguments.	2017-06-04 08:02:14 +01:00
jzmaddock	81a7c92b6c	CI: Add missing dependency to utility.	2017-06-01 08:48:02 +01:00
jzmaddock	4406ec8039	Merge branch 'develop' of https://github.com/boostorg/integer into develop	2017-05-31 18:45:28 +01:00
jzmaddock	8e63e7f284	CI: Add more testers and minimise dependencies.	2017-05-31 18:45:16 +01:00
John Maddock	0c956331a0	Fix gmp test failures	2017-05-09 19:52:20 +01:00
jzmaddock	943d63e309	Fix use of check-target-builds in Jamfile.	2017-05-09 18:03:03 +01:00
jzmaddock	7ccb820893	Test mpz_class when available. And fix errors compiling with that type.	2017-05-07 13:15:15 +01:00
John Maddock	84ded579f3	Qualify recursive calls to avoid ambiguity for types that have their own gcd/lcm	2017-05-04 11:12:33 +01:00
John Maddock	c1a08d3185	We can enable compiler intrinsics with GCC in C++14 mode after all	2017-04-30 18:49:47 +01:00
John Maddock	53306630db	Fix for Oracle 12.4 compiler	2017-04-27 17:23:40 +00:00
jzmaddock	1d934167fd	Tentative fix for overload resolution issue with Oracle C++.	2017-04-26 19:51:03 +01:00
jzmaddock	9c75396c05	Fix more explicit instantiations in test cases.	2017-04-26 19:11:18 +01:00
jzmaddock	7c0151c93a	Enumerators don't need a final , in their list.	2017-04-26 18:30:11 +01:00
jzmaddock	52e2dba49b	Merge branch 'develop' of https://github.com/boostorg/integer into develop	2017-04-26 18:24:22 +01:00
jzmaddock	395735a193	Add tests for multiprecision types and fix test program to still compile.	2017-04-26 18:24:09 +01:00
Peter Dimov	240b96ddec	Add appveyor.yml	2017-04-25 17:26:57 +03:00
jzmaddock	6af0e7ee85	Merge branch 'develop' of https://github.com/boostorg/integer into develop	2017-04-24 19:20:02 +01:00
jzmaddock	4991d82385	Need to take abs of return value in short-circuit gcd code.	2017-04-24 19:19:48 +01:00
Peter Dimov	2b133e8ea8	Merge branch 'develop' of https://github.com/boostorg/integer into develop	2017-04-24 21:08:11 +03:00
Peter Dimov	55e81c5ba7	Fetch test dependencies in .travis.yml	2017-04-24 21:07:48 +03:00
jzmaddock	52ce75ed65	Merge branch 'develop' of https://github.com/boostorg/integer into develop # Please enter a commit message to explain why this merge is necessary, # especially if it merges an updated upstream into a topic branch. # # Lines starting with '#' will be ignored, and an empty message aborts # the commit.	2017-04-24 18:52:16 +01:00
jzmaddock	3e43dd6fc2	Update history.	2017-04-24 18:50:19 +01:00
Peter Dimov	b2dcad8daf	Add .travis.yml	2017-04-24 20:49:14 +03:00
jzmaddock	58d53beae4	Add missing #include for older compilers.	2017-04-24 18:18:36 +01:00
jzmaddock	f5eff7d83d	MSVC-8 has no <intrin.h>.	2017-04-24 18:13:56 +01:00
jzmaddock	efb84707f0	Update docs to match new gcd/lcm code.	2017-04-24 13:01:57 +01:00
jzmaddock	beb6871864	Switch over to using new Boost.Math version of gcd/lcm. Please refer to the Boost.Math revision log for details of changes, but in summary: * New version of gcd/lcm internals by Jeremy Murphy include mixed-binary algorithm and better selection logic. * Support is now included for gcd's of polynomials. * Full C++14 constexpr support.	2017-04-23 13:01:09 +01:00
jzmaddock	162e48d14a	Remove dependency to mpl and type_traits.	2017-03-31 18:34:14 +01:00
jzmaddock	74939edefe	Merge branch 'cpp14' into develop	2017-03-30 19:07:30 +01:00
jzmaddock	f650385f65	Disable test case that causes msvc internal error.	2017-03-30 18:50:57 +01:00
jzmaddock	39d9701857	Enable one more noexcept test	2017-03-28 19:30:48 +01:00
jzmaddock	45cc025bbd	Merge branch 'bugfix/bitwise-not-and-gcc6' of https://github.com/Flast/boost-integer into cpp14	2017-03-28 19:28:51 +01:00
jzmaddock	13b36d8432	Add tests for C++14 support.	2017-03-28 19:06:13 +01:00
jzmaddock	a52bae3639	Improve C++14 support: * Make functions constexpr. * Make functions noexcept where appropriate. * Add test case for the above.	2017-03-28 18:57:50 +01:00
Rene Rivera	0d964fe6fc	Add, and update, documentation build targets.	2016-10-10 11:39:50 -05:00
Rene Rivera	13b153c657	Add, and update, documentation build targets.	2016-10-07 23:07:34 -05:00
Kohei Takahashi	89cec128bd	Fix compile error on GCC6 or later. Bitwise not yields integral promotion and to be signed type.	2016-07-30 16:12:07 +09:00
Vicente J. Botet Escriba	14020f6f6c	Merge branch 'develop'	2015-03-09 08:10:54 +01:00
pabristow	175a1caa58	Placed GCD and LCM typdefs and declarations in integer_fwd.hpp inside namespace boost::integer (was in boost::math) and checked that expected tests pass (and expected fails fail). (Major update to Boost.Integer docs available for review at https://dl.dropboxusercontent.com/u/43940943/modular-boost/libs/integer/index.html on branch doc-revision).	2015-01-29 11:53:02 +00:00
Vicente J. Botet Escriba	1ff7278d5f	Added compile fail test for uint_t<65>. related to #6169 .	2015-01-25 17:26:09 +01:00
Vicente J. Botet Escriba	a12b96c011	manage with #4881 .	2015-01-25 17:11:04 +01:00
Vicente J. Botet Escriba	7ffb75bb43	manage with #6694 Boost.Integer part.	2015-01-25 17:03:09 +01:00
jzmaddock	83feb20e51	Missing #include Test case uses mpl:: types without including the needed header - exposed by ongoing type traits rewrite.	2015-01-23 19:05:59 +00:00
Peter Dimov	66ae9dc182	Merge branch 'develop'	2015-01-18 20:04:57 +02:00
Peter Dimov	603f412c1b	Merge branch 'develop'	2015-01-13 20:54:39 +02:00
Peter Dimov	de8b1d86f4	Merge branch 'develop'	2015-01-13 19:50:23 +02:00
Peter Dimov	163c26a2d4	Merge branch 'develop'	2015-01-13 18:44:48 +02:00
Peter Dimov	7d41c244ea	Merge branch 'develop'	2014-06-08 01:38:20 +03:00