Remove C++03 CI jobs, use gcc-11 libstdc++ in clang-12 through 15.

boost::swap is deprecated and will be removed. Use boost::core::invoke_swap
as a replacement.

.drone.star

@@ -0,0 +1,49 @@
+# Use, modification, and distribution are
+# subject to the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE.txt)
+#
+# Copyright Rene Rivera 2020.
+
+# For Drone CI we use the Starlark scripting language to reduce duplication.
+# As the yaml syntax for Drone CI is rather limited.
+#
+#
+globalenv={}
+linuxglobalimage="cppalliance/droneubuntu1404:1"
+windowsglobalimage="cppalliance/dronevs2019"
+
+def main(ctx):
+  return [
+  linux_cxx("TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98,0x Job 0", "g++", packages="g++-4.4", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.4', 'CXXSTD': '98,0x', 'DRONE_JOB_UUID': 'b6589fc6ab'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x Job 1", "g++", packages="g++-4.6", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.6', 'CXXSTD': '03,0x', 'DRONE_JOB_UUID': '356a192b79'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11 Job 2", "g++-4.7", packages="g++-4.7", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.7', 'CXXSTD': '03,11', 'DRONE_JOB_UUID': 'da4b9237ba'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11 Job 3", "g++-4.8", packages="g++-4.8", buildtype="boost", image="cppalliance/droneubuntu1604:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.8', 'CXXSTD': '03,11', 'DRONE_JOB_UUID': '77de68daec'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11 Job 4", "g++-4.9", packages="g++-4.9", buildtype="boost", image="cppalliance/droneubuntu1604:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-4.9', 'CXXSTD': '03,11', 'DRONE_JOB_UUID': '1b64538924'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z Job 5", "g++-5", packages="g++-5", buildtype="boost", image="cppalliance/droneubuntu1604:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-5', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'ac3478d69a'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z Job 6", "g++-6", packages="g++-6", buildtype="boost", image="cppalliance/droneubuntu1604:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'c1dfd96eea'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17 Job 7", "g++-7", packages="g++-7", buildtype="boost", image="cppalliance/droneubuntu1604:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-7', 'CXXSTD': '03,11,14,17', 'DRONE_JOB_UUID': '902ba3cda1'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17 Job 8", "g++-8", packages="g++-8", buildtype="boost", image="cppalliance/droneubuntu1604:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': '03,11,14,17,2a', 'DRONE_JOB_UUID': 'fe5dbbcea5'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-9 CXXSTD=03,11,14,17 Job 9", "g++-9", packages="g++-9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': '03,11,14,17,2a', 'DRONE_JOB_UUID': '0ade7c2cf9'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=gcc COMPILER=g++-10 CXXSTD=03,11,14,1 Job 10", "g++-10", packages="g++-10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': '03,11,14,17,20', 'DRONE_JOB_UUID': 'b1d5781111'}, globalenv=globalenv),
+  linux_cxx("UBSAN=1 TOOLSET=gcc COMPILER=g++-10 CXXSTD=03 Job 11", "g++-10", packages="g++-10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'UBSAN': '1', 'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': '03,11,14,17,20', 'UBSAN_OPTIONS': 'print_stacktrace=1', 'LINKFLAGS': '-fuse-ld=gold', 'DRONE_JOB_UUID': '17ba079149'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-3.4 CXXSTD=03, Job 12", "clang++", packages="clang-3.4 libstdc++-4.9-dev", llvm_os="trusty", llvm_ver="3.4", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.4', 'CXXSTD': '03,11', 'DRONE_JOB_UUID': '7b52009b64'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03, Job 13", "clang++", packages="clang-3.5 libstdc++-4.9-dev", llvm_os="trusty", llvm_ver="3.5", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.5', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'bd307a3ec3'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03, Job 14", "clang++", packages="clang-3.6 libstdc++-5-dev", llvm_os="trusty", llvm_ver="3.6", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.6', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'fa35e19212'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03, Job 15", "clang++", packages="clang-3.7 libstdc++-5-dev", llvm_os="trusty", llvm_ver="3.7", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.7', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'f1abd67035'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03, Job 16", "clang++-3.8", packages="clang-3.8 libstdc++-6-dev", llvm_os="xenial", llvm_ver="3.8", buildtype="boost", image="cppalliance/droneubuntu1604:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.8', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': '1574bddb75'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03, Job 17", "clang++-3.9", packages="clang-3.9 libstdc++-6-dev", llvm_os="xenial", llvm_ver="3.9", buildtype="boost", image="cppalliance/droneubuntu1604:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-3.9', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': '0716d9708d'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03, Job 18", "clang++-4.0", packages="clang-4.0 libstdc++-6-dev", llvm_os="xenial", llvm_ver="4.0", buildtype="boost", image="cppalliance/droneubuntu1604:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-4.0', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': '9e6a55b6b4'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03, Job 19", "clang++-5.0", packages="clang-5.0 libstdc++-7-dev", llvm_os="xenial", llvm_ver="5.0", buildtype="boost", image="cppalliance/droneubuntu1604:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-5.0', 'CXXSTD': '03,11,14,1z', 'DRONE_JOB_UUID': 'b3f0c7f6bb'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03, Job 20", "clang++-6.0", packages="clang-6.0 libstdc++-8-dev", llvm_os="xenial", llvm_ver="6.0", buildtype="boost", image="cppalliance/droneubuntu1604:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-6.0', 'CXXSTD': '03,11,14,17,2a', 'DRONE_JOB_UUID': '91032ad7bb'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-7 CXXSTD=03,11 Job 21", "clang++-7", packages="clang-7 libstdc++-8-dev", llvm_os="xenial", llvm_ver="7", buildtype="boost", image="cppalliance/droneubuntu1604:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-7', 'CXXSTD': '03,11,14,17,2a', 'DRONE_JOB_UUID': '472b07b9fc'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-8 CXXSTD=03,11 Job 22", "clang++-8", packages="clang-8 libstdc++-8-dev", llvm_os="xenial", llvm_ver="8", buildtype="boost", image="cppalliance/droneubuntu1604:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-8', 'CXXSTD': '03,11,14,17,2a', 'DRONE_JOB_UUID': '12c6fc06c9'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-9 CXXSTD=03,11 Job 23", "clang++-9", packages="clang-9 libstdc++-9-dev", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1604:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': '03,11,14,17,2a', 'DRONE_JOB_UUID': 'd435a6cdd7'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-10 CXXSTD=03,1 Job 24", "clang++-10", packages="clang-10 libstdc++-9-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1604:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': '03,11,14,17,20', 'DRONE_JOB_UUID': '4d134bc072'}, globalenv=globalenv),
+  linux_cxx("UBSAN=1 TOOLSET=clang COMPILER=clang++-10 CXX Job 25", "clang++-10", packages="clang-10 libstdc++-9-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1604:1", environment={'UBSAN': '1', 'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': '03,11,14,17,20', 'UBSAN_OPTIONS': 'print_stacktrace=1', 'DRONE_JOB_UUID': 'f6e1126ced'}, globalenv=globalenv),
+  linux_cxx("TOOLSET=clang COMPILER=clang++-10 CXXSTD=03,1 Job 26", "clang++-10", packages="clang-10 libc++-10-dev libc++abi-10-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1604:1", environment={'CXXFLAGS': '-stdlib=libc++', 'LINKFLAGS': '-stdlib=libc++', 'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': '03,11,14,17,20', 'DRONE_JOB_UUID': '887309d048'}, globalenv=globalenv),
+  linux_cxx("UBSAN=1 TOOLSET=clang COMPILER=clang++-10 CXX Job 27", "clang++-10", packages="clang-10 libc++-10-dev libc++abi-10-dev", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1604:1", environment={'CXXFLAGS': '-stdlib=libc++', 'LINKFLAGS': '-stdlib=libc++', 'UBSAN': '1', 'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': '03,11,14,17,20', 'UBSAN_OPTIONS': 'print_stacktrace=1', 'DRONE_JOB_UUID': 'bc33ea4e26'}, globalenv=globalenv),
+  osx_cxx("TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,1 Job 28", "clang++", packages="", buildtype="boost", xcode_version="11.2", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '03,11,14,17', 'DRONE_JOB_UUID': '0a57cb53ba'}, globalenv=globalenv),
+  ]
+
+# from https://github.com/boostorg/boost-ci
+load("@boost_ci//ci/drone/:functions.star", "linux_cxx","windows_cxx","osx_cxx","freebsd_cxx")

.drone/after-success.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+

.drone/before-install.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+

.drone/before-script.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+

.drone/boost.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+
+set -ex
+export TRAVIS_BUILD_DIR=$(pwd)
+export DRONE_BUILD_DIR=$(pwd)
+export TRAVIS_BRANCH=$DRONE_BRANCH
+export VCS_COMMIT_ID=$DRONE_COMMIT
+export GIT_COMMIT=$DRONE_COMMIT
+export REPO_NAME=$DRONE_REPO
+export PATH=~/.local/bin:/usr/local/bin:$PATH
+
+echo '==================================> BEFORE_INSTALL'
+
+. .drone/before-install.sh
+
+echo '==================================> INSTALL'
+
+GIT_FETCH_JOBS=8
+BOOST_BRANCH=develop
+if [ "$TRAVIS_BRANCH" = "master" ]; then BOOST_BRANCH=master; fi
+cd ..
+git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+cd boost-root
+git submodule init tools/boostdep
+git submodule init tools/build
+git submodule init tools/boost_install
+git submodule init libs/headers
+git submodule init libs/config
+git submodule update --jobs $GIT_FETCH_JOBS
+cp -r $TRAVIS_BUILD_DIR/* libs/integer
+python tools/boostdep/depinst/depinst.py --git_args "--jobs $GIT_FETCH_JOBS" integer
+./bootstrap.sh
+./b2 headers
+
+echo '==================================> BEFORE_SCRIPT'
+
+. $DRONE_BUILD_DIR/.drone/before-script.sh
+
+echo '==================================> SCRIPT'
+
+echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+BUILD_JOBS=`(nproc || sysctl -n hw.ncpu) 2> /dev/null`
+./b2 -j $BUILD_JOBS libs/integer/test toolset=$TOOLSET cxxstd=$CXXSTD ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined define=UBSAN=1 debug-symbols=on visibility=global} ${CXXFLAGS:+cxxflags="$CXXFLAGS"} ${LINKFLAGS:+linkflags="$LINKFLAGS"}
+
+echo '==================================> AFTER_SUCCESS'
+
+. $DRONE_BUILD_DIR/.drone/after-success.sh

.github/workflows/ci.yml

@@ -0,0 +1,488 @@
+# Copyright 2021-2023 Andrey Semashev
+#
+# 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)
+
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+      - develop
+      - feature/**
+
+concurrency:
+  group: ${{format('{0}:{1}', github.repository, github.ref)}}
+  cancel-in-progress: true
+
+env:
+  GIT_FETCH_JOBS: 8
+  NET_RETRY_COUNT: 5
+  DEFAULT_BUILD_VARIANT: debug,release
+
+jobs:
+  posix:
+    defaults:
+      run:
+        shell: bash
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Linux, gcc
+          - toolset: gcc-4.6
+            cxxstd: "0x"
+            os: ubuntu-latest
+            container: ubuntu:16.04
+            install:
+              - g++-4.6
+            sources:
+              - "ppa:ubuntu-toolchain-r/test"
+          - toolset: gcc-4.7
+            cxxstd: "11"
+            os: ubuntu-latest
+            container: ubuntu:16.04
+            install:
+              - g++-4.7
+          - toolset: gcc-4.8
+            cxxstd: "11"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install:
+              - g++-4.8
+          - toolset: gcc-4.9
+            cxxstd: "11"
+            os: ubuntu-latest
+            container: ubuntu:16.04
+            install:
+              - g++-4.9
+          - toolset: gcc-5
+            cxxstd: "11,14,1z"
+            os: ubuntu-latest
+            container: ubuntu:16.04
+            install:
+              - g++-5
+          - toolset: gcc-6
+            cxxstd: "11,14,1z"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install:
+              - g++-6
+          - toolset: gcc-7
+            cxxstd: "11,14,17"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install:
+              - g++-7
+          - toolset: gcc-8
+            cxxstd: "11,14,17,2a"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install:
+              - g++-8
+          - toolset: gcc-9
+            cxxstd: "11,14,17,2a"
+            os: ubuntu-20.04
+            install:
+              - g++-9
+          - toolset: gcc-10
+            cxxstd: "11,14,17,20"
+            os: ubuntu-20.04
+            install:
+              - g++-10
+          - toolset: gcc-11
+            cxxstd: "03-gnu,11-gnu,14-gnu,17-gnu,20-gnu,23-gnu"
+            os: ubuntu-22.04
+            install:
+              - g++-11
+          - toolset: gcc-12
+            cxxstd: "03-gnu,11-gnu,14-gnu,17-gnu,20-gnu,23-gnu"
+            os: ubuntu-22.04
+            install:
+              - g++-12
+          - name: UBSAN
+            toolset: gcc-11
+            cxxstd: "03-gnu,11-gnu,14-gnu,17-gnu,20-gnu,23-gnu"
+            ubsan: 1
+            build_variant: debug
+            os: ubuntu-22.04
+            install:
+              - g++-11
+
+          # Linux, clang
+          - toolset: clang
+            compiler: clang++-3.5
+            cxxstd: "11"
+            os: ubuntu-latest
+            container: ubuntu:16.04
+            install:
+              - clang-3.5
+          - toolset: clang
+            compiler: clang++-3.6
+            cxxstd: "11,14"
+            os: ubuntu-latest
+            container: ubuntu:16.04
+            install:
+              - clang-3.6
+          - toolset: clang
+            compiler: clang++-3.7
+            cxxstd: "11,14"
+            os: ubuntu-latest
+            container: ubuntu:16.04
+            install:
+              - clang-3.7
+          - toolset: clang
+            compiler: clang++-3.8
+            cxxstd: "11,14"
+            os: ubuntu-latest
+            container: ubuntu:16.04
+            install:
+              - clang-3.8
+          - toolset: clang
+            compiler: clang++-3.9
+            cxxstd: "11,14"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install:
+              - clang-3.9
+          - toolset: clang
+            compiler: clang++-4.0
+            cxxstd: "11,14"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install:
+              - clang-4.0
+          - toolset: clang
+            compiler: clang++-5.0
+            cxxstd: "11,14,1z"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install:
+              - clang-5.0
+          - toolset: clang
+            compiler: clang++-6.0
+            cxxstd: "11,14,17"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install:
+              - clang-6.0
+          - toolset: clang
+            compiler: clang++-7
+            cxxstd: "11,14,17"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install:
+              - clang-7
+          # Note: clang-8 does not fully support C++20, so it is not compatible with libstdc++-8 in this mode
+          - toolset: clang
+            compiler: clang++-8
+            cxxstd: "11,14,17,2a"
+            os: ubuntu-latest
+            container: ubuntu:18.04
+            install:
+              - clang-8
+              - g++-7
+            gcc_toolchain: 7
+          - toolset: clang
+            compiler: clang++-9
+            cxxstd: "11,14,17,2a"
+            os: ubuntu-20.04
+            install:
+              - clang-9
+          - toolset: clang
+            compiler: clang++-10
+            cxxstd: "11,14,17,20"
+            os: ubuntu-20.04
+            install:
+              - clang-10
+          - toolset: clang
+            compiler: clang++-11
+            cxxstd: "11,14,17,20"
+            os: ubuntu-22.04
+            install:
+              - clang-11
+          - toolset: clang
+            compiler: clang++-12
+            cxxstd: "03-gnu,11-gnu,14-gnu,17-gnu,20-gnu,2b-gnu"
+            os: ubuntu-22.04
+            install:
+              - clang-12
+              - g++-11
+            gcc_toolchain: 11
+          - toolset: clang
+            compiler: clang++-13
+            cxxstd: "03-gnu,11-gnu,14-gnu,17-gnu,20-gnu,2b-gnu"
+            os: ubuntu-22.04
+            install:
+              - clang-13
+              - g++-11
+            gcc_toolchain: 11
+          - toolset: clang
+            compiler: clang++-14
+            cxxstd: "03-gnu,11-gnu,14-gnu,17-gnu,20-gnu,2b-gnu"
+            os: ubuntu-22.04
+            install:
+              - clang-14
+              - g++-11
+            gcc_toolchain: 11
+          - toolset: clang
+            compiler: clang++-15
+            cxxstd: "03-gnu,11-gnu,14-gnu,17-gnu,20-gnu,2b-gnu"
+            os: ubuntu-22.04
+            install:
+              - clang-15
+              - g++-11
+            gcc_toolchain: 11
+          - toolset: clang
+            compiler: clang++-15
+            cxxstd: "03-gnu,11-gnu,14-gnu,17-gnu,20-gnu,2b-gnu"
+            os: ubuntu-22.04
+            install:
+              - clang-15
+              - libc++-15-dev
+              - libc++abi-15-dev
+            cxxflags: -stdlib=libc++
+            linkflags: -stdlib=libc++
+          - toolset: clang
+            compiler: clang++-16
+            cxxstd: "03-gnu,11-gnu,14-gnu,17-gnu,20-gnu,2b-gnu"
+            os: ubuntu-22.04
+            install:
+              - clang-16
+            sources:
+              - "deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-16 main"
+            source_keys:
+              - "https://apt.llvm.org/llvm-snapshot.gpg.key"
+          - toolset: clang
+            compiler: clang++-16
+            cxxstd: "03-gnu,11-gnu,14-gnu,17-gnu,20-gnu,2b-gnu"
+            os: ubuntu-22.04
+            install:
+              - clang-16
+              - libc++-16-dev
+              - libc++abi-16-dev
+            sources:
+              - "deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-16 main"
+            source_keys:
+              - "https://apt.llvm.org/llvm-snapshot.gpg.key"
+            cxxflags: -stdlib=libc++
+            linkflags: -stdlib=libc++
+          - name: UBSAN
+            toolset: clang
+            compiler: clang++-15
+            cxxstd: "03-gnu,11-gnu,14-gnu,17-gnu,20-gnu,2b-gnu"
+            cxxflags: -stdlib=libc++
+            linkflags: -stdlib=libc++
+            ubsan: 1
+            build_variant: debug
+            os: ubuntu-22.04
+            install:
+              - clang-15
+              - libc++-15-dev
+              - libc++abi-15-dev
+
+          - toolset: clang
+            cxxstd: "11,14,17,2a"
+            os: macos-11
+
+    timeout-minutes: 60
+    runs-on: ${{matrix.os}}
+    container: ${{matrix.container}}
+
+    steps:
+      - name: Setup environment
+        run: |
+            if [ -f "/etc/debian_version" ]
+            then
+                echo "DEBIAN_FRONTEND=noninteractive" >> $GITHUB_ENV
+                export DEBIAN_FRONTEND=noninteractive
+            fi
+            if [ -n "${{matrix.container}}" ]
+            then
+                echo "GHA_CONTAINER=${{matrix.container}}" >> $GITHUB_ENV
+                if [ -f "/etc/debian_version" ]
+                then
+                    apt-get -o Acquire::Retries=$NET_RETRY_COUNT update
+                    if [ "$(apt-cache search "^python-is-python3$" | wc -l)" -ne 0 ]
+                    then
+                        PYTHON_PACKAGE="python-is-python3"
+                    else
+                        PYTHON_PACKAGE="python"
+                    fi
+                    apt-get -o Acquire::Retries=$NET_RETRY_COUNT install -y sudo software-properties-common tzdata wget curl apt-transport-https ca-certificates make build-essential g++ $PYTHON_PACKAGE python3 perl git cmake
+                fi
+            fi
+            git config --global pack.threads 0
+
+      - uses: actions/checkout@v3
+
+      - name: Install packages
+        if: matrix.install
+        run: |
+            declare -a SOURCE_KEYS SOURCES
+            if [ -n "${{join(matrix.source_keys, ' ')}}" ]
+            then
+                SOURCE_KEYS=("${{join(matrix.source_keys, '" "')}}")
+            fi
+            if [ -n "${{join(matrix.sources, ' ')}}" ]
+            then
+                SOURCES=("${{join(matrix.sources, '" "')}}")
+            fi
+            for key in "${SOURCE_KEYS[@]}"
+            do
+                for i in {1..$NET_RETRY_COUNT}
+                do
+                    echo "Adding key: $key"
+                    wget -O - "$key" | sudo apt-key add - && break || sleep 2
+                done
+            done
+            if [ ${#SOURCES[@]} -gt 0 ]
+            then
+                APT_ADD_REPO_COMMON_ARGS=("-y")
+                APT_ADD_REPO_SUPPORTED_ARGS="$(apt-add-repository --help | perl -ne 'if (/^\s*-n/) { print "n"; } elsif (/^\s*-P/) { print "P"; } elsif (/^\s*-S/) { print "S"; } elsif (/^\s*-U/) { print "U"; }')"
+                if [ -n "$APT_ADD_REPO_SUPPORTED_ARGS" -a -z "${APT_ADD_REPO_SUPPORTED_ARGS##*n*}" ]
+                then
+                    APT_ADD_REPO_COMMON_ARGS+=("-n")
+                fi
+                APT_ADD_REPO_HAS_SOURCE_ARGS="$([ -n "$APT_ADD_REPO_SUPPORTED_ARGS" -a -z "${APT_ADD_REPO_SUPPORTED_ARGS##*P*}" -a -z "${APT_ADD_REPO_SUPPORTED_ARGS##*S*}" -a -z "${APT_ADD_REPO_SUPPORTED_ARGS##*U*}" ] && echo 1 || echo 0)"
+                for source in "${SOURCES[@]}"
+                do
+                    for i in {1..$NET_RETRY_COUNT}
+                    do
+                        APT_ADD_REPO_ARGS=("${APT_ADD_REPO_COMMON_ARGS[@]}")
+                        if [ $APT_ADD_REPO_HAS_SOURCE_ARGS -ne 0 ]
+                        then
+                            case "$source" in
+                            "ppa:"*)
+                                APT_ADD_REPO_ARGS+=("-P")
+                                ;;
+                            "deb "*)
+                                APT_ADD_REPO_ARGS+=("-S")
+                                ;;
+                            *)
+                                APT_ADD_REPO_ARGS+=("-U")
+                                ;;
+                            esac
+                        fi
+                        APT_ADD_REPO_ARGS+=("$source")
+                        echo "apt-add-repository ${APT_ADD_REPO_ARGS[@]}"
+                        sudo -E apt-add-repository "${APT_ADD_REPO_ARGS[@]}" && break || sleep 2
+                    done
+                done
+            fi
+            sudo apt-get -o Acquire::Retries=$NET_RETRY_COUNT update
+            sudo apt-get -o Acquire::Retries=$NET_RETRY_COUNT install -y ${{join(matrix.install, ' ')}}
+
+      - name: Setup GCC Toolchain
+        if: matrix.gcc_toolchain
+        run: |
+            GCC_TOOLCHAIN_ROOT="$HOME/gcc-toolchain"
+            echo "GCC_TOOLCHAIN_ROOT=\"$GCC_TOOLCHAIN_ROOT\"" >> $GITHUB_ENV
+            MULTIARCH_TRIPLET="$(dpkg-architecture -qDEB_HOST_MULTIARCH)"
+            mkdir -p "$GCC_TOOLCHAIN_ROOT"
+            ln -s /usr/include "$GCC_TOOLCHAIN_ROOT/include"
+            ln -s /usr/bin "$GCC_TOOLCHAIN_ROOT/bin"
+            mkdir -p "$GCC_TOOLCHAIN_ROOT/lib/gcc/$MULTIARCH_TRIPLET"
+            ln -s "/usr/lib/gcc/$MULTIARCH_TRIPLET/${{matrix.gcc_toolchain}}" "$GCC_TOOLCHAIN_ROOT/lib/gcc/$MULTIARCH_TRIPLET/${{matrix.gcc_toolchain}}"
+
+      - name: Setup Boost
+        run: |
+            echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+            LIBRARY=${GITHUB_REPOSITORY#*/}
+            echo LIBRARY: $LIBRARY
+            echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+            echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+            echo GITHUB_REF: $GITHUB_REF
+            REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+            REF=${REF#refs/heads/}
+            echo REF: $REF
+            BOOST_BRANCH=develop && [ "$REF" = "master" ] && BOOST_BRANCH=master || true
+            echo BOOST_BRANCH: $BOOST_BRANCH
+            BUILD_JOBS=$((nproc || sysctl -n hw.ncpu) 2> /dev/null)
+            echo "BUILD_JOBS=$BUILD_JOBS" >> $GITHUB_ENV
+            echo "CMAKE_BUILD_PARALLEL_LEVEL=$BUILD_JOBS" >> $GITHUB_ENV
+            DEPINST_ARGS=()
+            GIT_VERSION="$(git --version | sed -e 's/git version //')"
+            GIT_HAS_JOBS=1
+            if [ -f "/etc/debian_version" ]
+            then
+                if $(dpkg --compare-versions "$GIT_VERSION" lt 2.8.0)
+                then
+                    GIT_HAS_JOBS=0
+                fi
+            else
+                declare -a GIT_VER=(${GIT_VERSION//./ })
+                declare -a GIT_MIN_VER=(2 8 0)
+                for ((i=0; i<${#GIT_VER[@]}; i++))
+                do
+                    if [ -z "${GIT_MIN_VER[i]}" ]
+                    then
+                        GIT_MIN_VER[i]=0
+                    fi
+                    if [ "${GIT_VER[i]}" -lt "${GIT_MIN_VER[i]}" ]
+                    then
+                        GIT_HAS_JOBS=0
+                        break
+                    fi
+                done
+            fi
+            if [ "$GIT_HAS_JOBS" -ne 0 ]
+            then
+                DEPINST_ARGS+=("--git_args" "--jobs $GIT_FETCH_JOBS")
+            fi
+            cd ..
+            git clone -b "$BOOST_BRANCH" --depth 1 "https://github.com/boostorg/boost.git" "boost-root"
+            cd boost-root
+            mkdir -p libs/$LIBRARY
+            cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+            git submodule update --init tools/boostdep
+            DEPINST_ARGS+=("$LIBRARY")
+            python tools/boostdep/depinst/depinst.py "${DEPINST_ARGS[@]}"
+            if [ -z "${{matrix.cmake_tests}}" ]
+            then
+                ./bootstrap.sh
+                ./b2 headers
+                if [ -n "${{matrix.compiler}}" -o -n "$GCC_TOOLCHAIN_ROOT" ]
+                then
+                    echo -n "using ${{matrix.toolset}} : : ${{matrix.compiler}}" > ~/user-config.jam
+                    if [ -n "$GCC_TOOLCHAIN_ROOT" ]
+                    then
+                        echo -n " : <compileflags>\"--gcc-toolchain=$GCC_TOOLCHAIN_ROOT\" <linkflags>\"--gcc-toolchain=$GCC_TOOLCHAIN_ROOT\"" >> ~/user-config.jam
+                    fi
+                    echo " ;" >> ~/user-config.jam
+                fi
+            fi
+
+      - name: Run tests
+        if: matrix.cmake_tests == ''
+        run: |
+            cd ../boost-root
+            B2_ARGS=("-j" "$BUILD_JOBS" "toolset=${{matrix.toolset}}" "cxxstd=${{matrix.cxxstd}}")
+            if [ -n "${{matrix.build_variant}}" ]
+            then
+                B2_ARGS+=("variant=${{matrix.build_variant}}")
+            else
+                B2_ARGS+=("variant=$DEFAULT_BUILD_VARIANT")
+            fi
+            if [ -n "${{matrix.threading}}" ]
+            then
+                B2_ARGS+=("threading=${{matrix.threading}}")
+            fi
+            if [ -n "${{matrix.ubsan}}" ]
+            then
+                export UBSAN_OPTIONS="print_stacktrace=1"
+                B2_ARGS+=("cxxflags=-fsanitize=undefined -fno-sanitize-recover=undefined" "linkflags=-fsanitize=undefined -fuse-ld=gold" "define=UBSAN=1" "debug-symbols=on" "visibility=global")
+            fi
+            if [ -n "${{matrix.cxxflags}}" ]
+            then
+                B2_ARGS+=("cxxflags=${{matrix.cxxflags}}")
+            fi
+            if [ -n "${{matrix.linkflags}}" ]
+            then
+                B2_ARGS+=("linkflags=${{matrix.linkflags}}")
+            fi
+            B2_ARGS+=("libs/$LIBRARY/test")
+            ./b2 "${B2_ARGS[@]}"

CMakeLists.txt

@@ -0,0 +1,22 @@
+# Copyright 2018 Peter Dimov
+# Copyright 2018 Andrey Semashev
+# Distributed under the Boost Software License, Version 1.0.
+# See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.5...3.20)
+
+project(boost_integer VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+
+add_library(boost_integer INTERFACE)
+add_library(Boost::integer ALIAS boost_integer)
+
+target_include_directories(boost_integer INTERFACE include)
+
+target_link_libraries(boost_integer
+    INTERFACE
+        Boost::assert
+        Boost::config
+        Boost::core
+        Boost::static_assert
+        Boost::throw_exception
+)

README.md

@@ -0,0 +1,32 @@
+# 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
+
+Branch          | GitHub Actions | Drone | AppVeyor | Test Matrix | Dependencies |
+:-------------: | -------------- | ----- | -------- | ----------- | ------------ |
+[`master`](https://github.com/boostorg/integer/tree/master) | [![GitHub Actions](https://github.com/boostorg/integer/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/boostorg/integer/actions?query=branch%3Amaster) | [![Drone](https://drone.cpp.al/api/badges/boostorg/integer/status.svg?ref=refs/heads/master)](https://drone.cpp.al/boostorg/integer) | [![AppVeyor](https://ci.appveyor.com/api/projects/status/iugyf5rf51n99g3w/branch/master?svg=true)](https://ci.appveyor.com/project/Lastique/integer/branch/master) | [![Tests](https://img.shields.io/badge/matrix-master-brightgreen.svg)](http://www.boost.org/development/tests/master/developer/integer.html) | [![Dependencies](https://img.shields.io/badge/deps-master-brightgreen.svg)](https://pdimov.github.io/boostdep-report/master/integer.html)
+[`develop`](https://github.com/boostorg/integer/tree/develop) | [![GitHub Actions](https://github.com/boostorg/integer/actions/workflows/ci.yml/badge.svg?branch=develop)](https://github.com/boostorg/integer/actions?query=branch%3Adevelop) | [![Drone](https://drone.cpp.al/api/badges/boostorg/integer/status.svg?ref=refs/heads/develop)](https://drone.cpp.al/boostorg/integer) | [![AppVeyor](https://ci.appveyor.com/api/projects/status/iugyf5rf51n99g3w/branch/develop?svg=true)](https://ci.appveyor.com/project/Lastique/integer/branch/develop) | [![Tests](https://img.shields.io/badge/matrix-develop-brightgreen.svg)](http://www.boost.org/development/tests/develop/developer/integer.html) | [![Dependencies](https://img.shields.io/badge/deps-develop-brightgreen.svg)](https://pdimov.github.io/boostdep-report/develop/integer.html)
+
+### License
+
+Distributed under the [Boost Software License, Version 1.0](https://www.boost.org/LICENSE_1_0.txt).

appveyor.yml

@@ -0,0 +1,82 @@
+# Copyright 2019 Andrey Semashev
+# 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
+    - /feature\/.*/
+
+environment:
+  matrix:
+    - TOOLSET: msvc-14.0
+      CXXSTD: 14,latest
+      ADDRMD: 32,64
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - TOOLSET: msvc-14.1
+      CXXSTD: 14,17,latest
+      ADDRMD: 32,64
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+    - TOOLSET: msvc-14.2
+      ADDRMD: 32,64
+      CXXSTD: 14,17,20,latest
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+    - TOOLSET: msvc-14.3
+      ADDRMD: 32,64
+      CXXSTD: 14,17,20,latest
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022
+    - TOOLSET: clang-win
+      ADDRMD: 32,64
+      CXXSTD: 14,17,latest
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+    - TOOLSET: gcc
+      CXXSTD: 11,14,1z
+      ADDPATH: C:\cygwin\bin;
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - TOOLSET: gcc
+      CXXSTD: 11,14,1z
+      ADDPATH: C:\cygwin64\bin;
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - TOOLSET: gcc
+      CXXSTD: 11,14,1z
+      ADDPATH: C:\mingw\bin;
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - TOOLSET: gcc
+      CXXSTD: 11,14,1z
+      ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - TOOLSET: gcc
+      CXXSTD: 11,14,1z
+      ADDPATH: C:\mingw-w64\x86_64-7.3.0-posix-seh-rt_v5-rev0\mingw64\bin;
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+
+install:
+  - set GIT_FETCH_JOBS=8
+  - set BOOST_BRANCH=develop
+  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
+  - cd ..
+  - git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule init tools/build
+  - git submodule init tools/boostdep
+  - git submodule init tools/boost_install
+  - git submodule init libs/headers
+  - git submodule init libs/config
+  - git submodule update --jobs %GIT_FETCH_JOBS%
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\integer
+  - python tools/boostdep/depinst/depinst.py --git_args "--jobs %GIT_FETCH_JOBS%" integer
+  - cmd /c bootstrap
+  - b2 -d0 headers
+
+build: off
+
+test_script:
+  - PATH=%ADDPATH%%PATH%
+  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
+  - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
+  - b2 -j %NUMBER_OF_PROCESSORS% libs/integer/test toolset=%TOOLSET% %CXXSTD% %ADDRMD%

doc/Jamfile.v2

@@ -2,7 +2,7 @@
 
 # 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)
+# file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
 using quickbook ;
 
@@ -25,8 +25,8 @@ boostbook standalone
         # How far down we go with TOC's
         <xsl:param>generate.section.toc.level=4
         # Path for links to Boost:
-        <xsl:param>boost.root=../../../..
+        <xsl:param>"boost.root=../../../.."
-        
+
         # PDF Options:
         # TOC Generation: this is needed for FOP-0.9 and later:
         <xsl:param>fop1.extensions=0
@@ -46,10 +46,15 @@ boostbook standalone
         # default pnd graphics are awful in PDF form,
         # better use SVG's instead:
         <format>pdf:<xsl:param>admon.graphics.extension=".svg"
-        <format>pdf:<xsl:param>admon.graphics.path=$(boost-images)/
+        <format>pdf:<xsl:param>"admon.graphics.path=$(boost-images)/"
-        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/regex/doc/html
+        <format>pdf:<xsl:param>"boost.url.prefix=https://www.boost.org/doc/libs/release/libs/integer/doc/html"
     ;
 
-install pdf-install : standalone : <location>. <install-type>PDF ;
+install pdfinstall : standalone/<format>pdf : <location>. <install-type>PDF ;
-
+explicit pdfinstall ;
 
+###############################################################################
+alias boostdoc ;
+explicit boostdoc ;
+alias boostrelease : standalone ;
+explicit boostrelease ;

doc/gcd/math-gcd.qbk

@@ -0,0 +1,290 @@
+
+[section:gcd_lcm Greatest Common Divisor and Least Common Multiple]
+
+[section Introduction]
+
+The class and function templates in <boost/math/common_factor.hpp>
+provide run-time and compile-time evaluation of the greatest common divisor
+(GCD) or least common multiple (LCM) of two integers.
+These facilities are useful for many numeric-oriented generic
+programming problems.
+
+[endsect]
+
+[section Synopsis]
+
+   namespace boost
+   {
+   namespace integer
+   {
+
+   template < typename IntegerType >
+      class gcd_evaluator;
+   template < typename IntegerType >
+      class lcm_evaluator;
+
+   template < typename IntegerType >
+      constexpr IntegerType  gcd( IntegerType const &a, IntegerType const &b );
+   template < typename IntegerType >
+      constexpr IntegerType  lcm( IntegerType const &a, IntegerType const &b );
+   template < typename IntegerType, typename... Args >
+      constexpr IntegerType  gcd( IntegerType const &a, IntegerType const &b, Args const&... );
+   template < typename IntegerType, typename... Args >
+      constexpr IntegerType  lcm( IntegerType const &a, IntegerType const &b, Args const&... );
+
+   template <typename I>
+   std::pair<typename std::iterator_traits<I>::value_type, I>
+      gcd_range(I first, I last);
+   template <typename I>
+   std::pair<typename std::iterator_traits<I>::value_type, I>
+      lcm_range(I first, I last);
+
+   typedef ``['see-below]`` static_gcd_type;
+
+   template < static_gcd_type Value1, static_gcd_type Value2 >
+      struct static_gcd;
+   template < static_gcd_type Value1, static_gcd_type Value2 >
+      struct static_lcm;
+
+   }
+   }
+
+[endsect]
+
+[section GCD Function Object]
+
+[*Header: ] [@../../../../boost/integer/common_factor_rt.hpp <boost/integer/common_factor_rt.hpp>]
+
+   template < typename IntegerType >
+   class boost::integer::gcd_evaluator
+   {
+   public:
+      // Types
+      typedef IntegerType  result_type;
+      typedef IntegerType  first_argument_type;
+      typedef IntegerType  second_argument_type;
+
+      // Function object interface
+      constexpr result_type  operator ()(
+	     first_argument_type const &a,
+         second_argument_type const &b ) const;
+   };
+
+The boost::integer::gcd_evaluator class template defines a function object
+class to return the greatest common divisor of two integers.
+The template is parameterized by a single type, called IntegerType here.
+This type should be a numeric type that represents integers.
+The result of the function object is always nonnegative, even if either of
+the operator arguments is negative.
+
+This function object class template is used in the corresponding version of
+the GCD function template. If a numeric type wants to customize evaluations
+of its greatest common divisors, then the type should specialize on the
+gcd_evaluator class template.
+
+Note that these function objects are `constexpr` in C++14 and later only.
+They are also declared `noexcept` when appropriate.
+
+[endsect]
+
+[section LCM Function Object]
+
+[*Header: ] [@../../../../boost/integer/common_factor_rt.hpp <boost/integer/common_factor_rt.hpp>]
+
+   template < typename IntegerType >
+   class boost::integer::lcm_evaluator
+   {
+   public:
+      // Types
+      typedef IntegerType  result_type;
+      typedef IntegerType  first_argument_type;
+      typedef IntegerType  second_argument_type;
+
+      // Function object interface
+      constexpr result_type  operator ()(
+		first_argument_type const &a,
+		second_argument_type const &b ) const;
+   };
+
+The boost::integer::lcm_evaluator class template defines a function object
+class to return the least common multiple of two integers. The template
+is parameterized by a single type, called IntegerType here. This type
+should be a numeric type that represents integers. The result of the
+function object is always nonnegative, even if either of the operator
+arguments is negative. If the least common multiple is beyond the range
+of the integer type, the results are undefined.
+
+This function object class template is used in the corresponding version
+of the LCM function template. If a numeric type wants to customize
+evaluations of its least common multiples, then the type should
+specialize on the lcm_evaluator class template.
+
+Note that these function objects are constexpr in C++14 and later only.
+They are also declared `noexcept` when appropriate.
+
+[endsect]
+
+[section:run_time Run-time GCD & LCM Determination]
+
+[*Header: ] [@../../../../boost/integer/common_factor_rt.hpp <boost/integer/common_factor_rt.hpp>]
+
+   template < typename IntegerType >
+   constexpr IntegerType  boost::integer::gcd( IntegerType const &a, IntegerType const &b );
+
+   template < typename IntegerType >
+   constexpr IntegerType  boost::integer::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::integer::gcd function template returns the greatest common
+(nonnegative) divisor of the two integers passed to it.
+`boost::integer::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::integer::lcm function template returns the least common
+(nonnegative) multiple of the two integers passed to it.
+As with gcd, there are range and variadic versions of the function for
+more than 2 arguments.
+
+Note that these functions are constexpr in C++14 and later only.
+They are also declared `noexcept` when appropriate.
+
+[endsect]
+
+[section:compile_time Compile time GCD and LCM determination]
+
+[note These functions are deprecated in favor of constexpr `gcd` and `lcm` on C++14 capable compilers.]
+
+[*Header: ] [@../../../../boost/integer/common_factor_ct.hpp <boost/integer/common_factor_ct.hpp>]
+
+   typedef ``['unspecified]`` static_gcd_type;
+
+   template < static_gcd_type Value1, static_gcd_type Value2 >
+   struct boost::integer::static_gcd : public mpl::integral_c<static_gcd_type, implementation_defined>
+   {
+   };
+
+   template < static_gcd_type Value1, static_gcd_type Value2 >
+   struct boost::integer::static_lcm : public mpl::integral_c<static_gcd_type, implementation_defined>
+   {
+   };
+
+The type `static_gcd_type` is the widest unsigned-integer-type that is supported
+for use in integral-constant-expressions by the compiler.  Usually this
+the same type as `boost::uintmax_t`, but may fall back to being `unsigned long`
+for some older compilers.
+
+The boost::integer::static_gcd and boost::integer::static_lcm class templates
+take two value-based template parameters of the ['static_gcd_type] type
+and inherit from the type `boost::mpl::integral_c`.
+Inherited from the base class, they have a member /value/
+that is the greatest common factor or least
+common multiple, respectively, of the template arguments.
+A compile-time error will occur if the least common multiple
+is beyond the range of `static_gcd_type`.
+
+[h3 Example]
+
+   #include <boost/integer/common_factor.hpp>
+   #include <algorithm>
+   #include <iterator>
+   #include <iostream>
+
+   int main()
+   {
+      using std::cout;
+      using std::endl;
+
+      cout << "The GCD and LCM of 6 and 15 are "
+      << boost::integer::gcd(6, 15) << " and "
+      << boost::integer::lcm(6, 15) << ", respectively."
+      << endl;
+
+      cout << "The GCD and LCM of 8 and 9 are "
+      << boost::integer::static_gcd<8, 9>::value
+      << " and "
+      << boost::integer::static_lcm<8, 9>::value
+      << ", respectively." << endl;
+
+      int  a[] = { 4, 5, 6 }, b[] = { 7, 8, 9 }, c[3];
+      std::transform( a, a + 3, b, c, boost::integer::gcd_evaluator<int>() );
+      std::copy( c, c + 3, std::ostream_iterator<int>(cout, " ") );
+   }
+
+[endsect]
+
+[section:gcd_header Header <boost/integer/common_factor.hpp>]
+
+This header simply includes the headers
+[@../../../../boost/integer/common_factor_ct.hpp <boost/integer/common_factor_ct.hpp>]
+and [@../../../../boost/integer/common_factor_rt.hpp <boost/integer/common_factor_rt.hpp>].
+
+Note this is a legacy header: it used to contain the actual implementation,
+but the compile-time and run-time facilities
+were moved to separate headers (since they were independent of each other).
+
+[endsect]
+
+[section:demo Demonstration Program]
+
+The program [@../../../../libs/integer/test/common_factor_test.cpp common_factor_test.cpp] is a demonstration of the results from
+instantiating various examples of the run-time GCD and LCM function
+templates and the compile-time GCD and LCM class templates.
+(The run-time GCD and LCM class templates are tested indirectly through
+the run-time function templates.)
+
+[endsect]
+
+[section Rationale]
+
+The greatest common divisor and least common multiple functions are
+greatly used in some numeric contexts, including some of the other
+Boost libraries. Centralizing these functions to one header improves
+code factoring and eases maintenance.
+
+[endsect]
+
+[section:gcd_history History]
+
+* 24th April 2017 Moved to Jeremy Murphy's improved algorithms, added constexpr and noexcept support,
+added compiler intrinsic support, added variadic and range based versions of the algorithms.
+* 13 May 2013 Moved into main Boost.Math Quickbook documentation.
+* 17 Dec 2005: Converted documentation to Quickbook Format.
+* 2 Jul 2002: Compile-time and run-time items separated to new headers.
+* 7 Nov 2001: Initial version
+
+[endsect]
+
+[section:gcd_credits Credits]
+
+The author of the Boost compilation of GCD and LCM computations is
+Daryle Walker. The code was prompted by existing code hiding in the
+implementations of Paul Moore's rational library and Steve Cleary's
+pool library. The code had updates by Helmut Zeisel.
+
+[endsect]
+
+[endsect]
+
+[/
+Copyright 2005, 2013 Daryle Walker.
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+https://www.boost.org/LICENSE_1_0.txt).
+]

doc/html/boost_integer/cstdint.html

@@ -1,289 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Standard Integer Types</title>
-<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Boost.Integer">
-<link rel="up" href="../index.html" title="Boost.Integer">
-<link rel="prev" href="../index.html" title="Boost.Integer">
-<link rel="next" href="traits.html" title="Integer Traits">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="traits.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.cstdint"></a><a class="link" href="cstdint.html" title="Standard Integer Types"> Standard Integer Types</a>
-</h2></div></div></div>
-<div class="toc"><dl>
-<dt><span class="section"><a href="cstdint.html#boost_integer.cstdint.overview">Overview</a></span></dt>
-<dt><span class="section"><a href="cstdint.html#boost_integer.cstdint.rationale"> Rationale</a></span></dt>
-<dt><span class="section"><a href="cstdint.html#boost_integer.cstdint.ce"> <span class="emphasis"><em>Caveat emptor</em></span></a></span></dt>
-<dt><span class="section"><a href="cstdint.html#boost_integer.cstdint.exact_width_integer_types">Exact-width
-      integer types</a></span></dt>
-<dt><span class="section"><a href="cstdint.html#boost_integer.cstdint.minimum_width_integer_types">Minimum-width
-      integer types</a></span></dt>
-<dt><span class="section"><a href="cstdint.html#boost_integer.cstdint.fastest_minimum_width_integer_types">Fastest
-      minimum-width integer types</a></span></dt>
-<dt><span class="section"><a href="cstdint.html#boost_integer.cstdint.greatest_width_integer_types">Greatest-width
-      integer types</a></span></dt>
-<dt><span class="section"><a href="cstdint.html#boost_integer.cstdint.integer_constant_macros">Integer
-      Constant Macros</a></span></dt>
-</dl></div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.cstdint.overview"></a><a class="link" href="cstdint.html#boost_integer.cstdint.overview" title="Overview">Overview</a>
-</h3></div></div></div>
-<p>
-        The header <code class="literal"><a href="../../../../../boost/cstdint.hpp" target="_top">&lt;boost/cstdint.hpp&gt;</a></code>
-        provides the typedef's useful for writing portable code that requires certain
-        integer widths. All typedef's are in namespace boost.
-      </p>
-<p>
-        The specifications for these types are based on the ISO/IEC 9899:1999 C Language
-        standard header &lt;stdint.h&gt;. The 64-bit types required by the C standard
-        are <span class="emphasis"><em>not required</em></span> in the boost header, and may not be
-        supplied for all platforms/compilers, because <code class="literal">long long</code>
-        is not [yet] included in the C++ standard.
-      </p>
-<p>
-        See <a href="../../../test/cstdint_test.cpp" target="_top">cstdint_test.cpp</a> for
-        a test program.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.cstdint.rationale"></a><a class="link" href="cstdint.html#boost_integer.cstdint.rationale" title="Rationale"> Rationale</a>
-</h3></div></div></div>
-<p>
-        The organization of the Boost.Integer headers and classes is designed to
-        take advantage of &lt;stdint.h&gt; types from the 1999 C standard without
-        causing undefined behavior in terms of the 1998 C++ standard. The header
-        &lt;boost/cstdint.hpp&gt; makes the standard integer types safely available
-        in namespace <code class="literal">boost</code> without placing any names in namespace
-        <code class="literal">std</code>. The intension is to complement rather than compete
-        with the C++ Standard Library. Should some future C++ standard include &lt;stdint.h&gt;
-        and &lt;cstdint&gt;, then &lt;boost/cstdint.hpp&gt; will continue to function,
-        but will become redundant and may be safely deprecated.
-      </p>
-<p>
-        Because these are boost headers, their names conform to boost header naming
-        conventions rather than C++ Standard Library header naming conventions.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.cstdint.ce"></a><a class="link" href="cstdint.html#boost_integer.cstdint.ce" title="Caveat emptor"> <span class="emphasis"><em>Caveat emptor</em></span></a>
-</h3></div></div></div>
-<p>
-        As an implementation artifact, certain C &lt;limits.h&gt; macro names may
-        possibly be visible to users of &lt;boost/cstdint.hpp&gt;. Don't use these
-        macros; they are not part of any Boost-specified interface. Use <code class="literal">boost::integer_traits&lt;&gt;</code>
-        or <code class="literal">std::numeric_limits&lt;&gt;</code> instead.
-      </p>
-<p>
-        As another implementation artifact, certain C &lt;stdint.h&gt; typedef names
-        may possibly be visible in the global namespace to users of &lt;boost/cstdint.hpp&gt;.
-        Don't use these names, they are not part of any Boost-specified interface.
-        Use the respective names in namespace <code class="literal">boost</code> instead.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.cstdint.exact_width_integer_types"></a><a class="link" href="cstdint.html#boost_integer.cstdint.exact_width_integer_types" title="Exact-width integer types">Exact-width
-      integer types</a>
-</h3></div></div></div>
-<p>
-        The typedef <code class="literal">int#_t</code>, with # replaced by the width, designates
-        a signed integer type of exactly # bits; for example <code class="literal">int8_t</code>
-        denotes an 8-bit signed integer type. Similarly, the typedef <code class="literal">uint#_t</code>
-        designates an unsigned integer type of exactly # bits.
-      </p>
-<p>
-        These types are optional. However, if a platform supports integer types with
-        widths of 8, 16, 32, 64, or any combination thereof, then &lt;boost/cstdint.hpp&gt;
-        does provide the corresponding typedefs.
-      </p>
-<p>
-        The absence of int64_t and uint64_t is indicated by the macro <code class="computeroutput"><span class="identifier">BOOST_NO_INT64_T</span></code>.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.cstdint.minimum_width_integer_types"></a><a class="link" href="cstdint.html#boost_integer.cstdint.minimum_width_integer_types" title="Minimum-width integer types">Minimum-width
-      integer types</a>
-</h3></div></div></div>
-<p>
-        The typedef <code class="literal">int_least#_t</code>, with # replaced by the width,
-        designates a signed integer type with a width of at least # bits, such that
-        no signed integer type with lesser size has at least the specified width.
-        Thus, <code class="literal">int_least32_t</code> denotes the smallest signed integer
-        type with a width of at least 32 bits. Similarly, the typedef name <code class="literal">uint_least#_t</code>
-        designates an unsigned integer type with a width of at least # bits, such
-        that no unsigned integer type with lesser size has at least the specified
-        width.
-      </p>
-<p>
-        The following minimum-width integer types are provided for all platforms:
-      </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-            <code class="literal">int_least8_t</code>
-          </li>
-<li class="listitem">
-            <code class="literal">int_least16_t</code>
-          </li>
-<li class="listitem">
-            <code class="literal">int_least32_t</code>
-          </li>
-<li class="listitem">
-            <code class="literal">uint_least8_t</code>
-          </li>
-<li class="listitem">
-            <code class="literal">uint_least16_t</code>
-          </li>
-<li class="listitem">
-            <code class="literal">uint_least32_t</code>
-          </li>
-</ul></div>
-<p>
-        The following types are available only if, after including &lt;boost/cstdint.hpp&gt;,
-        the macro BOOST_NO_INT64_T is not defined:
-      </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-            <code class="literal">int_least64_t</code>
-          </li>
-<li class="listitem">
-            <code class="literal">uint_least64_t</code>
-          </li>
-</ul></div>
-<p>
-        All other minimum-width integer types are optional.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.cstdint.fastest_minimum_width_integer_types"></a><a class="link" href="cstdint.html#boost_integer.cstdint.fastest_minimum_width_integer_types" title="Fastest minimum-width integer types">Fastest
-      minimum-width integer types</a>
-</h3></div></div></div>
-<p>
-        The typedef <code class="literal">int_fast#_t</code>, with # replaced by the width,
-        designates the fastest signed integer type with a width of at least # bits.
-        Similarly, the typedef name <code class="literal">uint_fast#_t</code> designates the
-        fastest unsigned integer type with a width of at least # bits.
-      </p>
-<p>
-        There is no guarantee that these types are fastest for all purposes. In any
-        case, however, they satisfy the signedness and width requirements.
-      </p>
-<p>
-        The following fastest minimum-width integer types are provided for all platforms:
-      </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-            <code class="literal">int_fast8_t</code>
-          </li>
-<li class="listitem">
-            <code class="literal">int_fast16_t</code>
-          </li>
-<li class="listitem">
-            <code class="literal">int_fast32_t</code>
-          </li>
-<li class="listitem">
-            <code class="literal">uint_fast8_t</code>
-          </li>
-<li class="listitem">
-            <code class="literal">uint_fast16_t</code>
-          </li>
-<li class="listitem">
-            <code class="literal">uint_fast32_t</code>
-          </li>
-</ul></div>
-<p>
-        The following types are available only if, after including &lt;boost/cstdint.hpp&gt;,
-        the macro BOOST_NO_INT64_T is not defined:
-      </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-            <code class="literal">int_fast64_t</code>
-          </li>
-<li class="listitem">
-            <code class="literal">uint_fast64_t</code>
-          </li>
-</ul></div>
-<p>
-        All other fastest minimum-width integer types are optional.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.cstdint.greatest_width_integer_types"></a><a class="link" href="cstdint.html#boost_integer.cstdint.greatest_width_integer_types" title="Greatest-width integer types">Greatest-width
-      integer types</a>
-</h3></div></div></div>
-<p>
-        The typedef <code class="literal">intmax_t </code>designates a signed integer type
-        capable of representing any value of any signed integer type.
-      </p>
-<p>
-        The typedef <code class="literal">uintmax_t</code> designates an unsigned integer type
-        capable of representing any value of any unsigned integer type.
-      </p>
-<p>
-        These types are provided for all platforms.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.cstdint.integer_constant_macros"></a><a class="link" href="cstdint.html#boost_integer.cstdint.integer_constant_macros" title="Integer Constant Macros">Integer
-      Constant Macros</a>
-</h3></div></div></div>
-<p>
-        The following macros are always defined after inclusion of this header, these
-        allow integer constants of at least the specified width to be declared: INT8_C,
-        UINT8_C, INT16_C, UINT16_C, INT32_C, UINT32_C, INTMAX_C, UINTMAX_C.
-      </p>
-<p>
-        The macros INT64_C and UINT64_C are also defined if the the macro BOOST_NO_INT64_T
-        is not defined.
-      </p>
-<p>
-        The C99 macro __STDC_CONSTANT_MACROS is also defined as an artifact of the
-        implementation.
-      </p>
-<p>
-        For example:
-      </p>
-<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">cstdint</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
-
-<span class="comment">// Here the constant 0x1FFFFFFFF has the correct suffix applied:
-</span><span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">uint64_t</span> <span class="identifier">c</span> <span class="special">=</span> <span class="identifier">INT64_C</span><span class="special">(</span><span class="number">0</span><span class="identifier">x1FFFFFFFF</span><span class="special">);</span> 
-</pre>
-</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="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="traits.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

doc/html/boost_integer/history.html

@@ -1,82 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>History</title>
-<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<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">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="minmax.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_integer.history"></a><a class="link" href="history.html" title="History"> History</a>
-</h2></div></div></div>
-<a name="boost_integer.history.1_42_0"></a><h5>
-<a name="id766183"></a>
-      <a class="link" href="history.html#boost_integer.history.1_42_0">1.42.0</a>
-    </h5>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-          Reverted Trunk to release branch state (i.e. a "known good state").
-        </li>
-<li class="listitem">
-          Fixed issues: <a href="https://svn.boost.org/trac/boost/ticket/653" target="_top">653</a>,
-          <a href="https://svn.boost.org/trac/boost/ticket/3084" target="_top">3084</a>,
-          <a href="https://svn.boost.org/trac/boost/ticket/3177" target="_top">3177</a>,
-          <a href="https://svn.boost.org/trac/boost/ticket/3180" target="_top">3180</a>,
-          <a href="https://svn.boost.org/trac/boost/ticket/3548" target="_top">3568</a>,
-          <a href="https://svn.boost.org/trac/boost/ticket/3657" target="_top">3657</a>,
-          <a href="https://svn.boost.org/trac/boost/ticket/2134" target="_top">2134</a>.
-        </li>
-<li class="listitem">
-          Added long long support to <code class="literal">boost::static_log2</code>, <code class="literal">boost::static_signed_min</code>,
-          <code class="literal">boost::static_signed_max</code>, <code class="literal">boost::static_unsigned_min</code><code class="literal">boost::static_unsigned_max</code>,
-          when available.
-        </li>
-<li class="listitem">
-          The argument type and the result type of <code class="literal">boost::static_signed_min</code>
-          etc are now typedef'd. Formerly, they were hardcoded as <code class="literal">unsigned
-          long</code> and <code class="literal">int</code> respectively. Please, use the
-          provided typedefs in new code (and update old code as soon as possible).
-        </li>
-</ul></div>
-<a name="boost_integer.history.1_32_0"></a><h5>
-<a name="id766314"></a>
-      <a class="link" href="history.html#boost_integer.history.1_32_0">1.32.0</a>
-    </h5>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
-          The argument type and the result type of <code class="literal">boost::static_log2</code>
-          are now typedef'd. Formerly, they were hardcoded as <code class="literal">unsigned long</code>
-          and <code class="literal">int</code> respectively. Please, use the provided typedefs
-          in new code (and update old code as soon as possible).
-        </li></ul></div>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#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="minmax.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a>
-</div>
-</body>
-</html>

doc/html/boost_integer/integer.html

@@ -1,432 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Integer Type Selection</title>
-<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<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">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="traits.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="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.integer"></a><a class="link" href="integer.html" title="Integer Type Selection"> Integer Type Selection</a>
-</h2></div></div></div>
-<div class="toc"><dl>
-<dt><span class="section"><a href="integer.html#boost_integer.integer.synopsis"> Synopsis</a></span></dt>
-<dt><span class="section"><a href="integer.html#boost_integer.integer.easiest"> Easiest-to-Manipulate
-      Types</a></span></dt>
-<dt><span class="section"><a href="integer.html#boost_integer.integer.sized"> Sized Types</a></span></dt>
-<dt><span class="section"><a href="integer.html#boost_integer.integer.example">Example</a></span></dt>
-<dt><span class="section"><a href="integer.html#boost_integer.integer.demonstration_program">Demonstration
-      Program</a></span></dt>
-<dt><span class="section"><a href="integer.html#boost_integer.integer.rationale">Rationale</a></span></dt>
-<dt><span class="section"><a href="integer.html#boost_integer.integer.alternative">Alternative</a></span></dt>
-<dt><span class="section"><a href="integer.html#boost_integer.integer.credits">Credits</a></span></dt>
-</dl></div>
-<p>
-      The <a href="../../../../../boost/integer.hpp" target="_top">&lt;boost/integer.hpp&gt;</a>
-      type selection templates allow integer types to be selected based on desired
-      characteristics such as number of bits or maximum value. This facility is particularly
-      useful for solving generic programming problems.
-    </p>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.integer.synopsis"></a><a class="link" href="integer.html#boost_integer.integer.synopsis" title="Synopsis"> Synopsis</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
-<span class="special">{</span>
-  <span class="comment">//  fast integers from least integers
-</span>  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">LeastInt</span><span class="special">&gt;</span>
-  <span class="keyword">struct</span> <span class="identifier">int_fast_t</span>
-  <span class="special">{</span>
-      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">type</span><span class="special">;</span>
-  <span class="special">};</span>
-
-  <span class="comment">//  signed
-</span>  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="identifier">Bits</span><span class="special">&gt;</span>
-  <span class="keyword">struct</span> <span class="identifier">int_t</span> 
-  <span class="special">{</span>
-      <span class="comment">/* Member exact may or may not be defined depending upon Bits */</span>
-      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">exact</span><span class="special">;</span>
-      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">least</span><span class="special">;</span>
-      <span class="keyword">typedef</span> <span class="identifier">int_fast_t</span><span class="special">&lt;</span><span class="identifier">least</span><span class="special">&gt;::</span><span class="identifier">fast</span>      <span class="identifier">fast</span><span class="special">;</span>
-  <span class="special">};</span>
-
-  <span class="comment">//  unsigned
-</span>  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="identifier">Bits</span><span class="special">&gt;</span>
-  <span class="keyword">struct</span> <span class="identifier">uint_t</span> 
-  <span class="special">{</span>
-      <span class="comment">/* Member exact may or may not be defined depending upon Bits */</span>
-      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">exact</span><span class="special">;</span>
-      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">least</span><span class="special">;</span>
-      <span class="keyword">typedef</span> <span class="identifier">int_fast_t</span><span class="special">&lt;</span><span class="identifier">least</span><span class="special">&gt;::</span><span class="identifier">fast</span>      <span class="identifier">fast</span><span class="special">;</span>
-  <span class="special">};</span>
-
-  <span class="comment">//  signed
-</span>  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="keyword">long</span> <span class="identifier">MaxValue</span><span class="special">&gt;</span>
-  <span class="keyword">struct</span> <span class="identifier">int_max_value_t</span> 
-  <span class="special">{</span>
-      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">least</span><span class="special">;</span>
-      <span class="keyword">typedef</span> <span class="identifier">int_fast_t</span><span class="special">&lt;</span><span class="identifier">least</span><span class="special">&gt;::</span><span class="identifier">fast</span>      <span class="identifier">fast</span><span class="special">;</span>
-  <span class="special">};</span>
-
-  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">long</span> <span class="keyword">long</span> <span class="identifier">MinValue</span><span class="special">&gt;</span>
-  <span class="keyword">struct</span> <span class="identifier">int_min_value_t</span> 
-  <span class="special">{</span>
-      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">least</span><span class="special">;</span>
-      <span class="keyword">typedef</span> <span class="identifier">int_fast_t</span><span class="special">&lt;</span><span class="identifier">least</span><span class="special">&gt;::</span><span class="identifier">fast</span>      <span class="identifier">fast</span><span class="special">;</span>
-  <span class="special">};</span>
-
-  <span class="comment">//  unsigned
-</span>  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="keyword">long</span> <span class="identifier">Value</span><span class="special">&gt;</span>
-  <span class="keyword">struct</span> <span class="identifier">uint_value_t</span> 
-  <span class="special">{</span>
-      <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">least</span><span class="special">;</span>
-      <span class="keyword">typedef</span> <span class="identifier">int_fast_t</span><span class="special">&lt;</span><span class="identifier">least</span><span class="special">&gt;::</span><span class="identifier">fast</span>      <span class="identifier">fast</span><span class="special">;</span>
-  <span class="special">};</span>
-<span class="special">}</span> <span class="comment">// namespace boost
-</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.integer.easiest"></a><a class="link" href="integer.html#boost_integer.integer.easiest" title="Easiest-to-Manipulate Types"> Easiest-to-Manipulate
-      Types</a>
-</h3></div></div></div>
-<p>
-        The <code class="literal">int_fast_t</code> class template maps its input type to the
-        next-largest type that the processor can manipulate the easiest, or to itself
-        if the input type is already an easy-to-manipulate type. For instance, processing
-        a bunch of <code class="literal">char</code> objects may go faster if they were converted
-        to <code class="literal">int</code> objects before processing. The input type, passed
-        as the only template parameter, must be a built-in integral type, except
-        <code class="literal">bool</code>. Unsigned integral types can be used, as well as
-        signed integral types. The output type is given as the nested type <code class="literal">fast</code>.
-      </p>
-<p>
-        <span class="bold"><strong>Implementation Notes:</strong></span> By default, the output
-        type is identical to the input type. Eventually, this code's implementation
-        should be customized for each platform to give accurate mappings between
-        the built-in types and the easiest-to-manipulate built-in types. Also, there
-        is no guarantee that the output type actually is easier to manipulate than
-        the input type.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.integer.sized"></a><a class="link" href="integer.html#boost_integer.integer.sized" title="Sized Types"> Sized Types</a>
-</h3></div></div></div>
-<p>
-        The <code class="literal">int_t</code>, <code class="literal">uint_t</code>, <code class="literal">int_max_value_t</code>,
-        <code class="literal">int_min_value_t</code>, and <code class="literal">uint_value_t</code> class
-        templates find the most appropiate built-in integral type for the given template
-        parameter. This type is given by the nested type <code class="literal">least</code>.
-        The easiest-to-manipulate version of that type is given by the nested type
-        <code class="literal">fast</code>. The following table describes each template's criteria.
-      </p>
-<div class="table">
-<a name="boost_integer.integer.sized.criteria_for_the_sized_type_class_templates"></a><p class="title"><b>Table&#160;1.&#160;Criteria for the Sized Type Class Templates</b></p>
-<div class="table-contents"><table class="table" summary="Criteria for the Sized Type Class Templates">
-<colgroup>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
-                <p>
-                  Class Template
-                </p>
-              </th>
-<th>
-                <p>
-                  Template Parameter Mapping
-                </p>
-              </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
-                <p>
-                  <code class="literal">boost::int_t&lt;N&gt;::least</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  The smallest, built-in, signed integral type with at least <span class="emphasis"><em>N</em></span>
-                  bits, including the sign bit. The parameter should be a positive
-                  number. A compile-time error results if the parameter is larger
-                  than the number of bits in the largest integer type.
-                </p>
-              </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  <code class="literal">boost::int_t&lt;N&gt;::fast</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  The easiest-to-manipulate, built-in, signed integral type with
-                  at least <span class="emphasis"><em>N</em></span> bits, including the sign bit. The
-                  parameter should be a positive number. A compile-time error results
-                  if the parameter is larger than the number of bits in the largest
-                  integer type.
-                </p>
-              </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  <code class="literal">boost::int_t&lt;N&gt;::exact</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  A built-in, signed integral type with exactly <span class="emphasis"><em>N</em></span>
-                  bits, including the sign bit. The parameter should be a positive
-                  number. Note that the member <span class="emphasis"><em>exact</em></span> is defined
-                  <span class="bold"><strong>only</strong></span> if there exists a type with
-                  exactly <span class="emphasis"><em>N</em></span> bits.
-                </p>
-              </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  <code class="literal">boost::uint_t&lt;N&gt;::least</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  The smallest, built-in, unsigned integral type with at least <span class="emphasis"><em>N</em></span>
-                  bits. The parameter should be a positive number. A compile-time
-                  error results if the parameter is larger than the number of bits
-                  in the largest integer type.
-                </p>
-              </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  <code class="literal">boost::uint_t&lt;N&gt;::fast</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  The easiest-to-manipulate, built-in, unsigned integral type with
-                  at least <span class="emphasis"><em>N</em></span> bits. The parameter should be a
-                  positive number. A compile-time error results if the parameter
-                  is larger than the number of bits in the largest integer type.
-                </p>
-              </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  <code class="literal">boost::uint_t&lt;N&gt;::exact</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  A built-in, unsigned integral type with exactly <span class="emphasis"><em>N</em></span>
-                  bits. The parameter should be a positive number. A compile-time
-                  error results if the parameter is larger than the number of bits
-                  in the largest integer type. Note that the member <span class="emphasis"><em>exact</em></span>
-                  is defined <span class="bold"><strong>only</strong></span> if there exists
-                  a type with exactly N bits.
-                </p>
-              </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  <code class="literal">boost::int_max_value_t&lt;V&gt;::last</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  The smallest, built-in, signed integral type that can hold all
-                  the values in the inclusive range <span class="emphasis"><em>0 - V</em></span>. The
-                  parameter should be a positive number.
-                </p>
-              </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  <code class="literal">boost::int_max_value_t&lt;V&gt;::fast</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  The easiest-to-manipulate, built-in, signed integral type that
-                  can hold all the values in the inclusive range <span class="emphasis"><em>0 - V</em></span>.
-                  The parameter should be a positive number.
-                </p>
-              </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  <code class="literal">boost::int_min_value_t&lt;V&gt;::least</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  The smallest, built-in, signed integral type that can hold all
-                  the values in the inclusive range <span class="emphasis"><em>V - 0</em></span>. The
-                  parameter should be a negative number.
-                </p>
-              </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  <code class="literal">boost::int_min_value_t&lt;V&gt;::fast</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  The easiest-to-manipulate, built-in, signed integral type that
-                  can hold all the values in the inclusive range <span class="emphasis"><em>V - 0</em></span>.
-                  The parameter should be a negative number.
-                </p>
-              </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  <code class="literal">boost::uint_value_t&lt;V&gt;::least</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  The smallest, built-in, unsigned integral type that can hold all
-                  positive values up to and including <span class="emphasis"><em>V</em></span>. The
-                  parameter should be a positive number.
-                </p>
-              </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  <code class="literal">boost::uint_value_t&lt;V&gt;::fast</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  The easiest-to-manipulate, built-in, unsigned integral type that
-                  can hold all positive values up to and including <span class="emphasis"><em>V</em></span>.
-                  The parameter should be a positive number.
-                </p>
-              </td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break">
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.integer.example"></a><a class="link" href="integer.html#boost_integer.integer.example" title="Example">Example</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
-
-<span class="comment">//...
-</span>
-<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
-<span class="special">{</span>
-    <span class="identifier">boost</span><span class="special">::</span><span class="identifier">int_t</span><span class="special">&lt;</span><span class="number">24</span><span class="special">&gt;::</span><span class="identifier">least</span> <span class="identifier">my_var</span><span class="special">;</span>  <span class="comment">// my_var has at least 24-bits
-</span>    <span class="comment">//...
-</span>    <span class="comment">// This one is guarenteed not to be truncated:
-</span>    <span class="identifier">boost</span><span class="special">::</span><span class="identifier">int_max_value_t</span><span class="special">&lt;</span><span class="number">1000</span><span class="special">&gt;::</span><span class="identifier">least</span> <span class="identifier">my1000</span> <span class="special">=</span> <span class="number">1000</span><span class="special">;</span>
-    <span class="comment">//...
-</span>    <span class="comment">// This one is guarenteed not to be truncated, and as fast
-</span>    <span class="comment">// to manipulate as possible, its size may be greater than
-</span>    <span class="comment">// that of my1000:
-</span>    <span class="identifier">boost</span><span class="special">::</span><span class="identifier">int_max_value_t</span><span class="special">&lt;</span><span class="number">1000</span><span class="special">&gt;::</span><span class="identifier">fast</span> <span class="identifier">my_fast1000</span> <span class="special">=</span> <span class="number">1000</span><span class="special">;</span>
-<span class="special">}</span>
-</pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.integer.demonstration_program"></a><a class="link" href="integer.html#boost_integer.integer.demonstration_program" title="Demonstration Program">Demonstration
-      Program</a>
-</h3></div></div></div>
-<p>
-        The program <a href="../../../test/integer_test.cpp" target="_top">integer_test.cpp</a>
-        is a simplistic demonstration of the results from instantiating various examples
-        of the sized type class templates.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.integer.rationale"></a><a class="link" href="integer.html#boost_integer.integer.rationale" title="Rationale">Rationale</a>
-</h3></div></div></div>
-<p>
-        The rationale for the design of the templates in this header includes:
-      </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-            Avoid recursion because of concern about C++'s limited guaranteed recursion
-            depth (17).
-          </li>
-<li class="listitem">
-            Avoid macros on general principles.
-          </li>
-<li class="listitem">
-            Try to keep the design as simple as possible.
-          </li>
-</ul></div>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.integer.alternative"></a><a class="link" href="integer.html#boost_integer.integer.alternative" title="Alternative">Alternative</a>
-</h3></div></div></div>
-<p>
-        If the number of bits required is known beforehand, it may be more appropriate
-        to use the types supplied in <a href="../../../../../boost/cstdint.hpp" target="_top">&lt;boost/cstdint.hpp&gt;</a>.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.integer.credits"></a><a class="link" href="integer.html#boost_integer.integer.credits" title="Credits">Credits</a>
-</h3></div></div></div>
-<p>
-        The author of most of the Boost integer type choosing templates is <a href="http://www.boost.org/people/beman_dawes.html" target="_top">Beman Dawes</a>. He
-        gives thanks to Valentin Bonnard and <a href="http://www.boost.org/people/kevlin_henney.htm" target="_top">Kevlin
-        Henney</a> for sharing their designs for similar templates. <a href="http://www.boost.org/people/daryle_walker.html" target="_top">Daryle
-        Walker</a> designed the value-based sized templates.
-      </p>
-</div>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#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="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>
-</div>
-</body>
-</html>

doc/html/boost_integer/log2.html

@@ -1,151 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Compile Time log2 Calculation</title>
-<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Boost.Integer">
-<link rel="up" href="../index.html" title="Boost.Integer">
-<link rel="prev" href="mask.html" title="Integer Masks">
-<link rel="next" href="minmax.html" title="Compile time min/max calculation">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="mask.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="minmax.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_integer.log2"></a><a class="link" href="log2.html" title="Compile Time log2 Calculation"> Compile Time log2 Calculation</a>
-</h2></div></div></div>
-<div class="toc"><dl>
-<dt><span class="section"><a href="log2.html#boost_integer.log2.synopsis">Synopsis</a></span></dt>
-<dt><span class="section"><a href="log2.html#boost_integer.log2.usage">Usage</a></span></dt>
-<dt><span class="section"><a href="log2.html#boost_integer.log2.demonstration_program">Demonstration
-      Program</a></span></dt>
-<dt><span class="section"><a href="log2.html#boost_integer.log2.rationale">Rationale</a></span></dt>
-<dt><span class="section"><a href="log2.html#boost_integer.log2.credits">Credits</a></span></dt>
-</dl></div>
-<p>
-      The class template in <a href="../../../../../boost/integer/static_log2.hpp" target="_top">&lt;boost/integer/static_log2.hpp&gt;</a>
-      determines the position of the highest bit in a given value. This facility
-      is useful for solving generic programming problems.
-    </p>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.log2.synopsis"></a><a class="link" href="log2.html#boost_integer.log2.synopsis" title="Synopsis">Synopsis</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
-<span class="special">{</span>
-
-  <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">static_log2_argument_type</span><span class="special">;</span>
-  <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">static_log2_result_type</span><span class="special">;</span>
-
-  <span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">static_log2_argument_type</span> <span class="identifier">arg</span><span class="special">&gt;</span>
-  <span class="keyword">struct</span> <span class="identifier">static_log2</span>
-  <span class="special">{</span>
-    <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">static_log2_result_type</span> <span class="identifier">value</span> <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
-  <span class="special">};</span>
-
-
-  <span class="keyword">template</span> <span class="special">&lt;</span> <span class="special">&gt;</span>
-  <span class="keyword">struct</span> <span class="identifier">static_log2</span><span class="special">&lt;</span> <span class="number">0</span> <span class="special">&gt;</span>
-  <span class="special">{</span>
-    <span class="comment">// The logarithm of zero is undefined.
-</span>  <span class="special">};</span>
-
-
-<span class="special">}</span>  <span class="comment">// namespace boost
-</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.log2.usage"></a><a class="link" href="log2.html#boost_integer.log2.usage" title="Usage">Usage</a>
-</h3></div></div></div>
-<p>
-        The <code class="literal">boost::static_log2</code> class template takes one template
-        parameter, a value of type <code class="literal">static_log2_argument_type</code>.
-        The template only defines one member, <code class="literal">value</code>, which gives
-        the truncated, base-two logarithm of the template argument.
-      </p>
-<p>
-        Since the logarithm of zero, for any base, is undefined, there is a specialization
-        of <code class="literal">static_log2</code> for a template argument of zero. This specialization
-        has no members, so an attempt to use the base-two logarithm of zero results
-        in a compile-time error.
-      </p>
-<p>
-        Note:
-      </p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem">
-            <code class="literal">static_log2_argument_type</code> is an <span class="emphasis"><em>unsigned
-            integer type</em></span> (C++ standard, 3.9.1p3).
-          </li>
-<li class="listitem">
-            <code class="literal">static_log2_result_type</code> is an <span class="emphasis"><em>integer type</em></span>
-            (C++ standard, 3.9.1p7).
-          </li>
-</ul></div>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.log2.demonstration_program"></a><a class="link" href="log2.html#boost_integer.log2.demonstration_program" title="Demonstration Program">Demonstration
-      Program</a>
-</h3></div></div></div>
-<p>
-        The program <a href="../../../test/static_log2_test.cpp" target="_top">static_log2_test.cpp</a>
-        is a simplistic demonstration of the results from instantiating various examples
-        of the binary logarithm class template.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.log2.rationale"></a><a class="link" href="log2.html#boost_integer.log2.rationale" title="Rationale">Rationale</a>
-</h3></div></div></div>
-<p>
-        The base-two (binary) logarithm, abbreviated lb, function is occasionally
-        used to give order-estimates of computer algorithms. The truncated logarithm
-        can be considered the highest power-of-two in a value, which corresponds
-        to the value's highest set bit (for binary integers). Sometimes the highest-bit
-        position could be used in generic programming, which requires the position
-        to be available statically (<span class="emphasis"><em>i.e.</em></span> at compile-time).
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.log2.credits"></a><a class="link" href="log2.html#boost_integer.log2.credits" title="Credits">Credits</a>
-</h3></div></div></div>
-<p>
-        The original version of the Boost binary logarithm class template was written
-        by <a href="http://www.boost.org/people/daryle_walker.html" target="_top">Daryle Walker</a>
-        and then enhanced by Giovanni Bajo with support for compilers without partial
-        template specialization. The current version was suggested, together with
-        a reference implementation, by Vesa Karvonen. Gennaro Prota wrote the actual
-        source file.
-      </p>
-</div>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#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="mask.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="minmax.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

doc/html/boost_integer/mask.html

@@ -1,378 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Integer Masks</title>
-<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<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="log2.html" title="Compile Time log2 Calculation">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="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>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_integer.mask"></a><a class="link" href="mask.html" title="Integer Masks"> Integer Masks</a>
-</h2></div></div></div>
-<div class="toc"><dl>
-<dt><span class="section"><a href="mask.html#boost_integer.mask.overview">Overview</a></span></dt>
-<dt><span class="section"><a href="mask.html#boost_integer.mask.synopsis">Synopsis</a></span></dt>
-<dt><span class="section"><a href="mask.html#boost_integer.mask.single_bit_mask_class_template">Single
-      Bit-Mask Class Template</a></span></dt>
-<dt><span class="section"><a href="mask.html#boost_integer.mask.group_bit_mask_class_template">Group
-      Bit-Mask Class Template</a></span></dt>
-<dt><span class="section"><a href="mask.html#boost_integer.mask.implementation_notes">Implementation
-      Notes</a></span></dt>
-<dt><span class="section"><a href="mask.html#boost_integer.mask.example">Example</a></span></dt>
-<dt><span class="section"><a href="mask.html#boost_integer.mask.demonstration_program">Demonstration
-      Program</a></span></dt>
-<dt><span class="section"><a href="mask.html#boost_integer.mask.rationale">Rationale</a></span></dt>
-<dt><span class="section"><a href="mask.html#boost_integer.mask.credits">Credits</a></span></dt>
-</dl></div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.mask.overview"></a><a class="link" href="mask.html#boost_integer.mask.overview" title="Overview">Overview</a>
-</h3></div></div></div>
-<p>
-        The class templates in <a href="../../../../../boost/integer/integer_mask.hpp" target="_top">&lt;boost/integer/integer_mask.hpp&gt;</a>
-        provide bit masks for a certain bit position or a contiguous-bit pack of
-        a certain size. The types of the masking constants come from the <a class="link" href="integer.html" title="Integer Type Selection">integer
-        type selection templates</a> header.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.mask.synopsis"></a><a class="link" href="mask.html#boost_integer.mask.synopsis" title="Synopsis">Synopsis</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">cstddef</span><span class="special">&gt;</span>  <span class="comment">// for std::size_t
-</span>
-<span class="keyword">namespace</span> <span class="identifier">boost</span>
-<span class="special">{</span>
-
-<span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Bit</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">high_bit_mask_t</span>
-<span class="special">{</span>
-    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">least</span><span class="special">;</span>
-    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">fast</span><span class="special">;</span>
-
-    <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">least</span>       <span class="identifier">high_bit</span>       <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
-    <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">fast</span>        <span class="identifier">high_bit_fast</span>  <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
-
-    <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">bit_position</span>   <span class="special">=</span> <span class="identifier">Bit</span><span class="special">;</span>
-<span class="special">};</span>
-
-<span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">Bits</span><span class="special">&gt;</span>
-<span class="keyword">struct</span> <span class="identifier">low_bits_mask_t</span>
-<span class="special">{</span>
-    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">least</span><span class="special">;</span>
-    <span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined-type</em></span>  <span class="identifier">fast</span><span class="special">;</span>
-
-    <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">least</span>       <span class="identifier">sig_bits</span>       <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
-    <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">fast</span>        <span class="identifier">sig_bits_fast</span>  <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
-
-    <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">bit_count</span>      <span class="special">=</span> <span class="identifier">Bits</span><span class="special">;</span>
-<span class="special">};</span>
-
-<span class="comment">// Specializations for low_bits_mask_t exist for certain bit counts.
-</span>
-<span class="special">}</span>  <span class="comment">// namespace boost
-</span></pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.mask.single_bit_mask_class_template"></a><a class="link" href="mask.html#boost_integer.mask.single_bit_mask_class_template" title="Single Bit-Mask Class Template">Single
-      Bit-Mask Class Template</a>
-</h3></div></div></div>
-<p>
-        The <code class="literal">boost::high_bit_mask_t</code> class template provides constants
-        for bit masks representing the bit at a certain position. The masks are equivalent
-        to the value 2<sup>Bit</sup>, where <code class="literal">Bit</code> is the template parameter.
-        The bit position must be a nonnegative number from zero to <span class="emphasis"><em>Max</em></span>,
-        where Max is one less than the number of bits supported by the largest unsigned
-        built-in integral type. The following table describes the members of an instantiation
-        of <code class="literal">high_bit_mask_t</code>.
-      </p>
-<div class="table">
-<a name="boost_integer.mask.single_bit_mask_class_template.members_of_the__boost__high_bit_mask_t__class_template"></a><p class="title"><b>Table&#160;2.&#160;Members of the `boost::high_bit_mask_t` Class Template</b></p>
-<div class="table-contents"><table class="table" summary="Members of the `boost::high_bit_mask_t` Class Template">
-<colgroup>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
-                <p>
-                  Member
-                </p>
-              </th>
-<th>
-                <p>
-                  Meaning
-                </p>
-              </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
-                <p>
-                  <code class="literal">least</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  The smallest, unsigned, built-in type that supports the given bit
-                  position.
-                </p>
-              </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  <code class="literal">fast</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  The easiest-to-manipulate analog of <code class="literal">least</code>.
-                </p>
-              </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  <code class="literal">high_bit</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  A <code class="literal">least</code> constant of the value 2<sup>Bit</sup>.
-                </p>
-              </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  <code class="literal">high_bit_fast</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  A <code class="literal">fast</code> analog of <code class="literal">high_bit</code>.
-                </p>
-              </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  <code class="literal">bit_position</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  The value of the template parameter, in case its needed from a
-                  renamed instantiation of the class template.
-                </p>
-              </td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break">
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.mask.group_bit_mask_class_template"></a><a class="link" href="mask.html#boost_integer.mask.group_bit_mask_class_template" title="Group Bit-Mask Class Template">Group
-      Bit-Mask Class Template</a>
-</h3></div></div></div>
-<p>
-        The <code class="literal">boost::low_bits_mask_t</code> class template provides constants
-        for bit masks equivalent to the value (2<sup>Bits</sup> - 1), where <code class="literal">Bits</code>
-        is the template parameter. The parameter <code class="literal">Bits</code> must be
-        a non-negative integer from zero to <span class="emphasis"><em>Max</em></span>, where Max is
-        the number of bits supported by the largest, unsigned, built-in integral
-        type. The following table describes the members of <code class="literal">low_bits_mask_t</code>.
-      </p>
-<div class="table">
-<a name="boost_integer.mask.group_bit_mask_class_template.members_of_the___boost__low_bits_mask_t__class_template"></a><p class="title"><b>Table&#160;3.&#160;Members of the [^boost::low_bits_mask_t] Class Template</b></p>
-<div class="table-contents"><table class="table" summary="Members of the [^boost::low_bits_mask_t] Class Template">
-<colgroup>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
-                <p>
-                  Member
-                </p>
-              </th>
-<th>
-                <p>
-                  Meaning
-                </p>
-              </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
-                <p>
-                  <code class="literal">least</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  The smallest, unsigned built-in type that supports the given bit
-                  count.
-                </p>
-              </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  <code class="literal">fast</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  The easiest-to-manipulate analog of <code class="literal">least</code>.
-                </p>
-              </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  <code class="literal">sig_bits</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  A <code class="literal">least</code> constant of the desired bit-masking
-                  value.
-                </p>
-              </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  <code class="literal">sig_bits_fast</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  A <code class="literal">fast</code> analog of <code class="literal">sig_bits</code>.
-                </p>
-              </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  <code class="literal">bit_count</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  The value of the template parameter, in case its needed from a
-                  renamed instantiation of the class template.
-                </p>
-              </td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break">
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.mask.implementation_notes"></a><a class="link" href="mask.html#boost_integer.mask.implementation_notes" title="Implementation Notes">Implementation
-      Notes</a>
-</h3></div></div></div>
-<p>
-        When <code class="literal">Bits</code> is the exact size of a built-in unsigned type,
-        the implementation has to change to prevent undefined behavior. Therefore,
-        there are specializations of <code class="literal">low_bits_mask_t</code> at those
-        bit counts.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.mask.example"></a><a class="link" href="mask.html#boost_integer.mask.example" title="Example">Example</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer</span><span class="special">/</span><span class="identifier">integer_mask</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
-
-<span class="comment">//...
-</span>
-<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
-<span class="special">{</span>
-    <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">high_bit_mask_t</span><span class="special">&lt;</span><span class="number">29</span><span class="special">&gt;</span>  <span class="identifier">mask1_type</span><span class="special">;</span>
-    <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">low_bits_mask_t</span><span class="special">&lt;</span><span class="number">15</span><span class="special">&gt;</span>  <span class="identifier">mask2_type</span><span class="special">;</span>
-
-    <span class="identifier">mask1_type</span><span class="special">::</span><span class="identifier">least</span>  <span class="identifier">my_var1</span><span class="special">;</span>
-    <span class="identifier">mask2_type</span><span class="special">::</span><span class="identifier">fast</span>   <span class="identifier">my_var2</span><span class="special">;</span>
-    <span class="comment">//...
-</span>
-    <span class="identifier">my_var1</span> <span class="special">|=</span> <span class="identifier">mask1_type</span><span class="special">::</span><span class="identifier">high_bit</span><span class="special">;</span>
-    <span class="identifier">my_var2</span> <span class="special">&amp;=</span> <span class="identifier">mask2_type</span><span class="special">::</span><span class="identifier">sig_bits_fast</span><span class="special">;</span>
-
-    <span class="comment">//...
-</span><span class="special">}</span>
-</pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.mask.demonstration_program"></a><a class="link" href="mask.html#boost_integer.mask.demonstration_program" title="Demonstration Program">Demonstration
-      Program</a>
-</h3></div></div></div>
-<p>
-        The program <a href="../../../test/integer_mask_test.cpp" target="_top">integer_mask_test.cpp</a>
-        is a simplistic demonstration of the results from instantiating various examples
-        of the bit mask class templates.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.mask.rationale"></a><a class="link" href="mask.html#boost_integer.mask.rationale" title="Rationale">Rationale</a>
-</h3></div></div></div>
-<p>
-        The class templates in this header are an extension of the <a class="link" href="integer.html" title="Integer Type Selection">integer
-        type selection class templates</a>. The new class templates provide the
-        same sized types, but also convenient masks to use when extracting the highest
-        or all the significant bits when the containing built-in type contains more
-        bits. This prevents contamination of values by the higher, unused bits.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.mask.credits"></a><a class="link" href="mask.html#boost_integer.mask.credits" title="Credits">Credits</a>
-</h3></div></div></div>
-<p>
-        The author of the Boost bit mask class templates is <a href="http://www.boost.org/people/daryle_walker.html" target="_top">Daryle
-        Walker</a>.
-      </p>
-</div>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#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="log2.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

doc/html/boost_integer/minmax.html

@@ -1,160 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Compile time min/max calculation</title>
-<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Boost.Integer">
-<link rel="up" href="../index.html" title="Boost.Integer">
-<link rel="prev" href="log2.html" title="Compile Time log2 Calculation">
-<link rel="next" href="history.html" title="History">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="log2.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="history.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_integer.minmax"></a><a class="link" href="minmax.html" title="Compile time min/max calculation"> Compile time min/max calculation</a>
-</h2></div></div></div>
-<div class="toc"><dl>
-<dt><span class="section"><a href="minmax.html#boost_integer.minmax.synopsis">Synopsis</a></span></dt>
-<dt><span class="section"><a href="minmax.html#boost_integer.minmax.usage">Usage</a></span></dt>
-<dt><span class="section"><a href="minmax.html#boost_integer.minmax.example">Example</a></span></dt>
-<dt><span class="section"><a href="minmax.html#boost_integer.minmax.demonstration_program">Demonstration
-      Program</a></span></dt>
-<dt><span class="section"><a href="minmax.html#boost_integer.minmax.rationale">Rationale</a></span></dt>
-<dt><span class="section"><a href="minmax.html#boost_integer.minmax.credits">Credits</a></span></dt>
-</dl></div>
-<p>
-      The class templates in <a href="../../../../../boost/integer/static_min_max.hpp" target="_top">&lt;boost/integer/static_min_max.hpp&gt;</a>
-      provide a compile-time evaluation of the minimum or maximum of two integers.
-      These facilities are useful for generic programming problems.
-    </p>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.minmax.synopsis"></a><a class="link" href="minmax.html#boost_integer.minmax.synopsis" title="Synopsis">Synopsis</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span>
-<span class="special">{</span>
-
-<span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">static_min_max_signed_type</span><span class="special">;</span>
-<span class="keyword">typedef</span> <span class="emphasis"><em>implementation-defined</em></span> <span class="identifier">static_min_max_unsigned_type</span><span class="special">;</span>
-
-<span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">static_min_max_signed_type</span> <span class="identifier">Value1</span><span class="special">,</span> <span class="identifier">static_min_max_signed_type</span> <span class="identifier">Value2</span> <span class="special">&gt;</span>
-    <span class="keyword">struct</span> <span class="identifier">static_signed_min</span><span class="special">;</span>
-
-<span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">static_min_max_signed_type</span> <span class="identifier">Value1</span><span class="special">,</span> <span class="identifier">static_min_max_signed_type</span> <span class="identifier">Value2</span><span class="special">&gt;</span>
-    <span class="keyword">struct</span> <span class="identifier">static_signed_max</span><span class="special">;</span>
-
-<span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">static_min_max_unsigned_type</span> <span class="identifier">Value1</span><span class="special">,</span> <span class="identifier">static_min_max_unsigned_type</span> <span class="identifier">Value2</span><span class="special">&gt;</span>
-    <span class="keyword">struct</span> <span class="identifier">static_unsigned_min</span><span class="special">;</span>
-
-<span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">static_min_max_unsigned_type</span> <span class="identifier">Value1</span><span class="special">,</span> <span class="identifier">static_min_max_unsigned_type</span> <span class="identifier">Value2</span><span class="special">&gt;</span>
-    <span class="keyword">struct</span> <span class="identifier">static_unsigned_max</span><span class="special">;</span>
-
-<span class="special">}</span>
-</pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.minmax.usage"></a><a class="link" href="minmax.html#boost_integer.minmax.usage" title="Usage">Usage</a>
-</h3></div></div></div>
-<p>
-        The four class templates provide the combinations for finding the minimum
-        or maximum of two <code class="literal">signed</code> or <code class="literal">unsigned</code>
-        (<code class="literal">long</code>) parameters, <span class="emphasis"><em>Value1</em></span> and <span class="emphasis"><em>Value2</em></span>,
-        at compile-time. Each template has a single static data member, <code class="literal">value</code>,
-        which is set to the respective minimum or maximum of the template's parameters.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.minmax.example"></a><a class="link" href="minmax.html#boost_integer.minmax.example" title="Example">Example</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">integer</span><span class="special">/</span><span class="identifier">static_min_max</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
-
-<span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="identifier">AddendSize1</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="identifier">AddendSize2</span> <span class="special">&gt;</span>
-<span class="keyword">class</span> <span class="identifier">adder</span>
-<span class="special">{</span>
-<span class="keyword">public</span><span class="special">:</span>
-    <span class="keyword">static</span>  <span class="keyword">unsigned</span> <span class="keyword">long</span>  <span class="keyword">const</span>  <span class="identifier">addend1_size</span> <span class="special">=</span> <span class="identifier">AddendSize1</span><span class="special">;</span>
-    <span class="keyword">static</span>  <span class="keyword">unsigned</span> <span class="keyword">long</span>  <span class="keyword">const</span>  <span class="identifier">addend2_size</span> <span class="special">=</span> <span class="identifier">AddendSize2</span><span class="special">;</span>
-    <span class="keyword">static</span>  <span class="keyword">unsigned</span> <span class="keyword">long</span>  <span class="keyword">const</span>  <span class="identifier">sum_size</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">static_unsigned_max</span><span class="special">&lt;</span><span class="identifier">AddendSize1</span><span class="special">,</span> <span class="identifier">AddendSize2</span><span class="special">&gt;::</span><span class="identifier">value</span> <span class="special">+</span> <span class="number">1</span><span class="special">;</span>
-
-    <span class="keyword">typedef</span> <span class="keyword">int</span>  <span class="identifier">addend1_type</span><span class="special">[</span> <span class="identifier">addend1_size</span> <span class="special">];</span>
-    <span class="keyword">typedef</span> <span class="keyword">int</span>  <span class="identifier">addend2_type</span><span class="special">[</span> <span class="identifier">addend2_size</span> <span class="special">];</span>
-    <span class="keyword">typedef</span> <span class="keyword">int</span>  <span class="identifier">sum_type</span><span class="special">[</span> <span class="identifier">sum_size</span> <span class="special">];</span>
-
-    <span class="keyword">void</span>  <span class="keyword">operator</span> <span class="special">()(</span> <span class="identifier">addend1_type</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">a1</span><span class="special">,</span> <span class="identifier">addend2_type</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="identifier">a2</span><span class="special">,</span> <span class="identifier">sum_type</span> <span class="special">&amp;</span><span class="identifier">s</span> <span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
-<span class="special">};</span>
-
-<span class="comment">//...
-</span>
-<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
-<span class="special">{</span>
-    <span class="keyword">int</span> <span class="keyword">const</span>   <span class="identifier">a1</span><span class="special">[]</span> <span class="special">=</span> <span class="special">{</span> <span class="number">0</span><span class="special">,</span> <span class="number">4</span><span class="special">,</span> <span class="number">3</span> <span class="special">};</span>  <span class="comment">// 340
-</span>    <span class="keyword">int</span> <span class="keyword">const</span>   <span class="identifier">a2</span><span class="special">[]</span> <span class="special">=</span> <span class="special">{</span> <span class="number">9</span><span class="special">,</span> <span class="number">8</span> <span class="special">};</span>     <span class="comment">//  89
-</span>    <span class="keyword">int</span>         <span class="identifier">s</span><span class="special">[</span> <span class="number">4</span> <span class="special">];</span>
-    <span class="identifier">adder</span><span class="special">&lt;</span><span class="number">3</span><span class="special">,</span><span class="number">2</span><span class="special">&gt;</span>  <span class="identifier">obj</span><span class="special">;</span>
-
-    <span class="identifier">obj</span><span class="special">(</span> <span class="identifier">a1</span><span class="special">,</span> <span class="identifier">a2</span><span class="special">,</span> <span class="identifier">s</span> <span class="special">);</span>  <span class="comment">// 's' should be 429 or { 9, 2, 4, 0 }
-</span>    <span class="comment">//...
-</span><span class="special">}</span>
-</pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.minmax.demonstration_program"></a><a class="link" href="minmax.html#boost_integer.minmax.demonstration_program" title="Demonstration Program">Demonstration
-      Program</a>
-</h3></div></div></div>
-<p>
-        The program <a href="../../../test/static_min_max_test.cpp" target="_top">static_min_max_test.cpp</a>
-        is a simplistic demonstration of various comparisons using the compile-time
-        extrema class templates.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.minmax.rationale"></a><a class="link" href="minmax.html#boost_integer.minmax.rationale" title="Rationale">Rationale</a>
-</h3></div></div></div>
-<p>
-        Sometimes the minimum or maximum of several values needs to be found for
-        later compile-time processing, <span class="emphasis"><em>e.g.</em></span> for a bound for
-        another class template.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.minmax.credits"></a><a class="link" href="minmax.html#boost_integer.minmax.credits" title="Credits">Credits</a>
-</h3></div></div></div>
-<p>
-        The author of the Boost compile-time extrema class templates is <a href="http://www.boost.org/people/daryle_walker.html" target="_top">Daryle
-        Walker</a>.
-      </p>
-</div>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#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="log2.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="history.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

doc/html/boost_integer/traits.html

@@ -1,215 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Integer Traits</title>
-<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="../index.html" title="Boost.Integer">
-<link rel="up" href="../index.html" title="Boost.Integer">
-<link rel="prev" href="cstdint.html" title="Standard Integer Types">
-<link rel="next" href="integer.html" title="Integer Type Selection">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
-<td align="center"><a href="../../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav">
-<a accesskey="p" href="cstdint.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="integer.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_integer.traits"></a><a class="link" href="traits.html" title="Integer Traits"> Integer Traits</a>
-</h2></div></div></div>
-<div class="toc"><dl>
-<dt><span class="section"><a href="traits.html#boost_integer.traits.motivation">Motivation</a></span></dt>
-<dt><span class="section"><a href="traits.html#boost_integer.traits.synopsis">Synopsis</a></span></dt>
-<dt><span class="section"><a href="traits.html#boost_integer.traits.description">Description</a></span></dt>
-<dt><span class="section"><a href="traits.html#boost_integer.traits.test_program">Test Program</a></span></dt>
-<dt><span class="section"><a href="traits.html#boost_integer.traits.acknowledgements">Acknowledgements</a></span></dt>
-</dl></div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.traits.motivation"></a><a class="link" href="traits.html#boost_integer.traits.motivation" title="Motivation">Motivation</a>
-</h3></div></div></div>
-<p>
-        The C++ Standard Library &lt;limits&gt; header supplies a class template
-        <code class="computeroutput"><span class="identifier">numeric_limits</span><span class="special">&lt;&gt;</span></code>
-        with specializations for each fundamental type.
-      </p>
-<p>
-        For integer types, the interesting members of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;&gt;</span></code> are:
-      </p>
-<pre class="programlisting"><span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">is_specialized</span><span class="special">;</span>      <span class="comment">// Will be true for integer types.
-</span><span class="keyword">static</span> <span class="identifier">T</span> <span class="identifier">min</span><span class="special">()</span> <span class="keyword">throw</span><span class="special">();</span>                <span class="comment">// Smallest representable value.
-</span><span class="keyword">static</span> <span class="identifier">T</span> <span class="identifier">max</span><span class="special">()</span> <span class="keyword">throw</span><span class="special">();</span>                <span class="comment">// Largest representable value.
-</span><span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">int</span> <span class="identifier">digits</span><span class="special">;</span>               <span class="comment">// For integers, the number of value bits.
-</span><span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">int</span> <span class="identifier">digits10</span><span class="special">;</span>             <span class="comment">// The number of base 10 digits that can be represented.
-</span><span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">is_signed</span><span class="special">;</span>           <span class="comment">// True if the type is signed.
-</span><span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">is_integer</span><span class="special">;</span>          <span class="comment">// Will be true for all integer types.
-</span></pre>
-<p>
-        For many uses, these are sufficient. But min() and max() are problematical
-        because they are not constant expressions (std::5.19), yet some usages require
-        constant expressions.
-      </p>
-<p>
-        The template class <code class="literal">integer_traits</code> addresses this problem.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.traits.synopsis"></a><a class="link" href="traits.html#boost_integer.traits.synopsis" title="Synopsis">Synopsis</a>
-</h3></div></div></div>
-<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
-  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
-  <span class="keyword">class</span> <span class="identifier">integer_traits</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span>
-  <span class="special">{</span>
-  <span class="keyword">public</span><span class="special">:</span>
-     <span class="keyword">static</span> <span class="keyword">const</span> <span class="keyword">bool</span> <span class="identifier">is_integral</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">;</span>
-     <span class="comment">//
-</span>     <span class="comment">// These members are defined only if T is a built-in
-</span>     <span class="comment">// integal type:
-</span>     <span class="comment">//
-</span>     <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">T</span> <span class="identifier">const_min</span> <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
-     <span class="keyword">static</span> <span class="keyword">const</span> <span class="identifier">T</span> <span class="identifier">const_max</span> <span class="special">=</span> <span class="emphasis"><em>implementation-defined</em></span><span class="special">;</span>
-  <span class="special">};</span>
-<span class="special">}</span>
-</pre>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.traits.description"></a><a class="link" href="traits.html#boost_integer.traits.description" title="Description">Description</a>
-</h3></div></div></div>
-<p>
-        Template class <code class="literal">integer_traits</code> is derived from <code class="literal">std::numeric_limits</code>.
-        The primary specialization adds the single <code class="literal">bool</code> member
-        <code class="literal">is_integral</code> with the compile-time constant value <code class="literal">false</code>.
-        However, for all integral types <code class="literal">T</code> (std::3.9.1/7 [basic.fundamental]),
-        there are specializations provided with the following compile-time constants
-        defined:
-      </p>
-<div class="informaltable"><table class="table">
-<colgroup>
-<col>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
-                <p>
-                  member
-                </p>
-              </th>
-<th>
-                <p>
-                  type
-                </p>
-              </th>
-<th>
-                <p>
-                  value
-                </p>
-              </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
-                <p>
-                  <code class="literal">is_integral</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  bool
-                </p>
-              </td>
-<td>
-                <p>
-                  <code class="literal">true</code>
-                </p>
-              </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  <code class="literal">const_min</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  <code class="literal">T</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  equivalent to <code class="literal">std::numeric_limits&lt;T&gt;::min()</code>
-                </p>
-              </td>
-</tr>
-<tr>
-<td>
-                <p>
-                  <code class="literal">const_max</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  <code class="literal">T</code>
-                </p>
-              </td>
-<td>
-                <p>
-                  equivalent to <code class="literal">std::numeric_limits&lt;T&gt;::max()</code>
-                </p>
-              </td>
-</tr>
-</tbody>
-</table></div>
-<p>
-        Note: The <span class="emphasis"><em>is_integral</em></span> flag is provided, because a user-defined
-        integer class should specialize <code class="literal">std::numeric_limits&lt;&gt;::is_integer
-        = true</code>, while compile-time constants <code class="literal">const_min</code>
-        and <code class="literal">const_max</code> are not provided for that user-defined class,
-        unless boost::integer_traits is also specialized.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.traits.test_program"></a><a class="link" href="traits.html#boost_integer.traits.test_program" title="Test Program">Test Program</a>
-</h3></div></div></div>
-<p>
-        The program <code class="literal"><a href="../../../test/integer_traits_test.cpp" target="_top">integer_traits_test.cpp</a></code>
-        exercises the <code class="literal">integer_traits</code> class.
-      </p>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h3 class="title">
-<a name="boost_integer.traits.acknowledgements"></a><a class="link" href="traits.html#boost_integer.traits.acknowledgements" title="Acknowledgements">Acknowledgements</a>
-</h3></div></div></div>
-<p>
-        Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers discussed the integer
-        traits idea on the boost mailing list in August 1999.
-      </p>
-</div>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"></td>
-<td align="right"><div class="copyright-footer">Copyright &#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="cstdint.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="integer.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
-</div>
-</body>
-</html>

doc/html/index.html

@@ -1,246 +0,0 @@
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
-<title>Boost.Integer</title>
-<link rel="stylesheet" href="../../../../doc/src/boostbook.css" type="text/css">
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="index.html" title="Boost.Integer">
-<link rel="next" href="boost_integer/cstdint.html" title="Standard Integer Types">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table cellpadding="2" width="100%"><tr>
-<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
-<td align="center"><a href="../../../../index.html">Home</a></td>
-<td align="center"><a href="../../../../libs/libraries.htm">Libraries</a></td>
-<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
-<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
-<td align="center"><a href="../../../../more/index.htm">More</a></td>
-</tr></table>
-<hr>
-<div class="spirit-nav"><a accesskey="n" href="boost_integer/cstdint.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
-<div class="article">
-<div class="titlepage">
-<div>
-<div><h2 class="title">
-<a name="boost_integer"></a>Boost.Integer</h2></div>
-<div><div class="authorgroup">
-<div class="author"><h3 class="author">
-<span class="firstname">Beman</span> <span class="surname">Dawes</span>
-</h3></div>
-<div class="author"><h3 class="author">
-<span class="firstname">Daryle</span> <span class="surname">Walker</span>
-</h3></div>
-<div class="author"><h3 class="author">
-<span class="firstname">Gennaro</span> <span class="surname">Prota</span>
-</h3></div>
-<div class="author"><h3 class="author">
-<span class="firstname">John</span> <span class="surname">Maddock</span>
-</h3></div>
-</div></div>
-<div><p class="copyright">Copyright &#169; 2001 -2009 Beman Dawes, Daryle Walker, Gennaro Prota,
-      John Maddock</p></div>
-<div><div class="legalnotice">
-<a name="id759732"></a><p>
-        Distributed under the Boost Software License, Version 1.0. (See accompanying
-        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
-      </p>
-</div></div>
-</div>
-<hr>
-</div>
-<div class="toc">
-<p><b>Table of Contents</b></p>
-<dl>
-<dt><span class="section"><a href="index.html#boost_integer.overview"> Overview</a></span></dt>
-<dt><span class="section"><a href="boost_integer/cstdint.html"> Standard Integer Types</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/mask.html"> Integer Masks</a></span></dt>
-<dt><span class="section"><a href="boost_integer/log2.html"> Compile Time log2 Calculation</a></span></dt>
-<dt><span class="section"><a href="boost_integer/minmax.html"> Compile time min/max calculation</a></span></dt>
-<dt><span class="section"><a href="boost_integer/history.html"> History</a></span></dt>
-</dl>
-</div>
-<div class="section">
-<div class="titlepage"><div><div><h2 class="title" style="clear: both">
-<a name="boost_integer.overview"></a><a class="link" href="index.html#boost_integer.overview" title="Overview"> Overview</a>
-</h2></div></div></div>
-<p>
-      Boost.Integer provides integer type support, particularly helpful in generic
-      programming. It provides standard C99 integer types, such as might be found
-      in &lt;stdint.h&gt;, without requiring that header. It provides the means to
-      select an integer type based upon its properties, like the number of bits or
-      the maximum supported value, as well as compile-time bit mask selection. There
-      is a derivative of std::numeric_limits that provides integral constant expressions
-      for <code class="computeroutput"><span class="identifier">min</span></code> and <code class="computeroutput"><span class="identifier">max</span></code>.
-      Finally, it provides two compile-time algorithms: determining the highest power
-      of two in a compile-time value; and computing min and max of constant expressions.
-    </p>
-<div class="informaltable"><table class="table">
-<colgroup>
-<col>
-<col>
-<col>
-</colgroup>
-<thead><tr>
-<th>
-              <p>
-                Component
-              </p>
-            </th>
-<th>
-              <p>
-                Header
-              </p>
-            </th>
-<th>
-              <p>
-                Purpose
-              </p>
-            </th>
-</tr></thead>
-<tbody>
-<tr>
-<td>
-              <p>
-                Forward Declarations.
-              </p>
-            </td>
-<td>
-              <p>
-                <code class="literal"><a href="../../../../boost/integer_fwd.hpp" target="_top">&lt;boost/integer_fwd.hpp&gt;</a></code>
-              </p>
-            </td>
-<td>
-              <p>
-                Forward declarations of classes and class templates - for use when
-                just the name of a class is needed.
-              </p>
-            </td>
-</tr>
-<tr>
-<td>
-              <p>
-                <a class="link" href="boost_integer/cstdint.html" title="Standard Integer Types">Standard Integer Types</a>.
-              </p>
-            </td>
-<td>
-              <p>
-                <code class="literal"><a href="../../../../boost/cstdint.hpp" target="_top">&lt;boost/cstdint.hpp&gt;</a></code>
-              </p>
-            </td>
-<td>
-              <p>
-                Provides typedef's based on the 1999 C Standard header <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">stdint</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span></code>, wrapped in namespace boost.
-                This implementation may #include the compiler supplied <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">stdint</span><span class="special">.</span><span class="identifier">h</span><span class="special">&gt;</span></code>, if present.
-              </p>
-            </td>
-</tr>
-<tr>
-<td>
-              <p>
-                <a class="link" href="boost_integer/traits.html" title="Integer Traits">Integer Traits</a>.
-              </p>
-            </td>
-<td>
-              <p>
-                <code class="literal"><a href="../../../../boost/integer_traits.hpp" target="_top">&lt;boost/integer_traits.hpp&gt;</a></code>
-              </p>
-            </td>
-<td>
-              <p>
-                Class template <code class="literal">boost::integer_traits</code>, derives
-                from <code class="literal">std::numeric_limits</code> and adds <code class="literal">const_min</code>
-                and <code class="literal">const_max</code> members.
-              </p>
-            </td>
-</tr>
-<tr>
-<td>
-              <p>
-                <a class="link" href="boost_integer/integer.html" title="Integer Type Selection">Integer Type Selection</a>.
-              </p>
-            </td>
-<td>
-              <p>
-                <code class="literal"><a href="../../../../boost/integer.hpp" target="_top">&lt;boost/integer.hpp&gt;</a></code>
-              </p>
-            </td>
-<td>
-              <p>
-                Templates for integer type selection based on properties such as
-                maximum value or number of bits: Use to select the type of an integer
-                when some property such as maximum value or number of bits is known.
-                Useful for generic programming.
-              </p>
-            </td>
-</tr>
-<tr>
-<td>
-              <p>
-                <a class="link" href="boost_integer/mask.html" title="Integer Masks">Integer Masks</a>.
-              </p>
-            </td>
-<td>
-              <p>
-                <code class="literal"><a href="../../../../boost/integer/integer_mask.hpp" target="_top">&lt;boost/integer/integer_mask.hpp&gt;</a></code>
-              </p>
-            </td>
-<td>
-              <p>
-                Templates for the selection of integer masks, single or lowest group,
-                based on the number of bits: Use to select a particular mask when
-                the bit position(s) are based on a compile-time variable. Useful
-                for generic programming.
-              </p>
-            </td>
-</tr>
-<tr>
-<td>
-              <p>
-                <a class="link" href="boost_integer/log2.html" title="Compile Time log2 Calculation">Compile time log2 Calculation</a>.
-              </p>
-            </td>
-<td>
-              <p>
-                <code class="literal"><a href="../../../../boost/integer/static_log2.hpp" target="_top">&lt;boost/integer/static_log2.hpp&gt;</a></code>
-              </p>
-            </td>
-<td>
-              <p>
-                Template for finding the highest power of two in a number: Use to
-                find the bit-size/range based on a maximum value. Useful for generic
-                programming.
-              </p>
-            </td>
-</tr>
-<tr>
-<td>
-              <p>
-                <a class="link" href="boost_integer/minmax.html" title="Compile time min/max calculation">Compile time min/max calculation</a>.
-              </p>
-            </td>
-<td>
-              <p>
-                <code class="literal"><a href="../../../../boost/integer/static_min_max.hpp" target="_top">&lt;boost/integer/static_min_max.hpp&gt;</a></code>
-              </p>
-            </td>
-<td>
-              <p>
-                Templates for finding the extrema of two numbers: Use to find a bound
-                based on a minimum or maximum value. Useful for generic programming.
-              </p>
-            </td>
-</tr>
-</tbody>
-</table></div>
-</div>
-</div>
-<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: July 08, 2010 at 20:45:20 GMT</small></p></td>
-<td align="right"><div class="copyright-footer"></div></td>
-</tr></table>
-<hr>
-<div class="spirit-nav"><a accesskey="n" href="boost_integer/cstdint.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
-</body>
-</html>

doc/integer.qbk

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

doc/modular_arithmetic/extended_euclidean.qbk

@@ -0,0 +1,53 @@
+[section:extended_euclidean Extended Euclidean Algorithm]
+
+[section Introduction]
+
+The extended Euclidean algorithm solves the integer relation /mx + ny/ = gcd(/m/, /n/) for /x/ and /y/.
+
+[endsect]
+
+[section Synopsis]
+
+    #include <boost/integer/extended_euclidean.hpp>
+
+    namespace boost { namespace integer {
+
+    template<class Z>
+    struct euclidean_result_t {
+      Z gcd;
+      Z x;
+      Z y;
+    };
+
+
+    template<class Z>
+    euclidean_result_t<Z> extended_euclidean(Z m, Z n);
+
+    }}
+
+[endsect]
+
+[section Usage]
+
+    int m = 12;
+    int n = 15;
+    auto res = extended_euclidean(m, n);
+
+    int gcd = res.gcd;
+    int x = res.x;
+    int y = res.y;
+    // mx + ny = gcd(m,n) should now hold
+
+[endsect]
+
+[section References]
+Wagstaff, Samuel S., ['The Joy of Factoring], Vol. 68. American Mathematical Soc., 2013.
+
+[endsect]
+[endsect]
+[/
+Copyright 2018 Nick Thompson.
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+https://www.boost.org/LICENSE_1_0.txt).
+]

doc/modular_arithmetic/mod_inverse.qbk

@@ -0,0 +1,50 @@
+[section:mod_inverse Modular Multiplicative Inverse]
+
+[section Introduction]
+
+The modular multiplicative inverse of a number /a/ is that number /x/ which satisfies /ax/ = 1 mod /p/.
+A fast algorithm for computing modular multiplicative inverses based on the extended Euclidean algorithm exists and is provided by Boost.
+
+[endsect]
+
+[section Synopsis]
+
+    #include <boost/integer/mod_inverse.hpp>
+
+    namespace boost { namespace integer {
+
+    template<class Z>
+    Z mod_inverse(Z a, Z m);
+
+    }}
+
+[endsect]
+
+[section Usage]
+
+    int x = mod_inverse(2, 5);
+    // prints x = 3:
+    std::cout << "x = " << x << "\n";
+
+    int y = mod_inverse(2, 4);
+    if (y == 0)
+    {
+        std::cout << "There is no inverse of 2 mod 4\n";
+    }
+
+Multiplicative modular inverses exist if and only if /a/ and /m/ are coprime.
+If /a/ and /m/ share a common factor, then `mod_inverse(a, m)` returns zero.
+
+[endsect]
+
+[section References]
+Wagstaff, Samuel S., ['The Joy of Factoring], Vol. 68. American Mathematical Soc., 2013.
+
+[endsect]
+[endsect]
+[/
+Copyright 2018 Nick Thompson.
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+https://www.boost.org/LICENSE_1_0.txt).
+]

include/boost/cstdint.hpp

@@ -1,508 +0,0 @@
-//  boost cstdint.hpp header file  ------------------------------------------//
-
-//  (C) Copyright Beman Dawes 1999. 
-//  (C) Copyright Jens Mauer 2001  
-//  (C) Copyright John Maddock 2001 
-//  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)
-
-//  See http://www.boost.org/libs/integer for documentation.
-
-//  Revision History
-//   31 Oct 01  use BOOST_HAS_LONG_LONG to check for "long long" (Jens M.)
-//   16 Apr 01  check LONGLONG_MAX when looking for "long long" (Jens Maurer)
-//   23 Jan 01  prefer "long" over "int" for int32_t and intmax_t (Jens Maurer)
-//   12 Nov 00  Merged <boost/stdint.h> (Jens Maurer)
-//   23 Sep 00  Added INTXX_C macro support (John Maddock).
-//   22 Sep 00  Better 64-bit support (John Maddock)
-//   29 Jun 00  Reimplement to avoid including stdint.h within namespace boost
-//    8 Aug 99  Initial version (Beman Dawes)
-
-
-#ifndef BOOST_CSTDINT_HPP
-#define BOOST_CSTDINT_HPP
-
-//
-// Since we always define the INT#_C macros as per C++0x, 
-// define __STDC_CONSTANT_MACROS so that <stdint.h> does the right
-// thing if possible, and so that the user knows that the macros 
-// are actually defined as per C99.
-//
-#ifndef __STDC_CONSTANT_MACROS
-#  define __STDC_CONSTANT_MACROS
-#endif
-
-#include <boost/config.hpp>
-
-//
-// Note that GLIBC is a bit inconsistent about whether int64_t is defined or not
-// depending upon what headers happen to have been included first...
-// so we disable use of stdint.h when GLIBC does not define __GLIBC_HAVE_LONG_LONG.
-// See https://svn.boost.org/trac/boost/ticket/3548 and http://sources.redhat.com/bugzilla/show_bug.cgi?id=10990
-//
-#if defined(BOOST_HAS_STDINT_H) && (!defined(__GLIBC__) || defined(__GLIBC_HAVE_LONG_LONG))
-
-// The following #include is an implementation artifact; not part of interface.
-# ifdef __hpux
-// HP-UX has a vaguely nice <stdint.h> in a non-standard location
-#   include <inttypes.h>
-#   ifdef __STDC_32_MODE__
-      // this is triggered with GCC, because it defines __cplusplus < 199707L
-#     define BOOST_NO_INT64_T
-#   endif 
-# elif defined(__FreeBSD__) || defined(__IBMCPP__) || defined(_AIX)
-#   include <inttypes.h>
-# else
-#   include <stdint.h>
-
-// There is a bug in Cygwin two _C macros
-#   if defined(__STDC_CONSTANT_MACROS) && defined(__CYGWIN__)
-#     undef INTMAX_C
-#     undef UINTMAX_C
-#     define INTMAX_C(c) c##LL
-#     define UINTMAX_C(c) c##ULL
-#   endif
-
-# endif
-
-#ifdef __QNX__
-
-// QNX (Dinkumware stdlib) defines these as non-standard names.
-// Reflect to the standard names.
-
-typedef ::intleast8_t int_least8_t;
-typedef ::intfast8_t int_fast8_t;
-typedef ::uintleast8_t uint_least8_t;
-typedef ::uintfast8_t uint_fast8_t;
-
-typedef ::intleast16_t int_least16_t;
-typedef ::intfast16_t int_fast16_t;
-typedef ::uintleast16_t uint_least16_t;
-typedef ::uintfast16_t uint_fast16_t;
-
-typedef ::intleast32_t int_least32_t;
-typedef ::intfast32_t int_fast32_t;
-typedef ::uintleast32_t uint_least32_t;
-typedef ::uintfast32_t uint_fast32_t;
-
-# ifndef BOOST_NO_INT64_T
-
-typedef ::intleast64_t int_least64_t;
-typedef ::intfast64_t int_fast64_t;
-typedef ::uintleast64_t uint_least64_t;
-typedef ::uintfast64_t uint_fast64_t;
-
-# endif
-
-#endif
-
-namespace boost
-{
-
-  using ::int8_t;             
-  using ::int_least8_t;       
-  using ::int_fast8_t;        
-  using ::uint8_t;            
-  using ::uint_least8_t;      
-  using ::uint_fast8_t;       
-                     
-  using ::int16_t;            
-  using ::int_least16_t;      
-  using ::int_fast16_t;       
-  using ::uint16_t;           
-  using ::uint_least16_t;     
-  using ::uint_fast16_t;      
-                     
-  using ::int32_t;            
-  using ::int_least32_t;      
-  using ::int_fast32_t;       
-  using ::uint32_t;           
-  using ::uint_least32_t;     
-  using ::uint_fast32_t;      
-                     
-# ifndef BOOST_NO_INT64_T
-
-  using ::int64_t;            
-  using ::int_least64_t;      
-  using ::int_fast64_t;       
-  using ::uint64_t;           
-  using ::uint_least64_t;     
-  using ::uint_fast64_t;      
-                     
-# endif
-
-  using ::intmax_t;      
-  using ::uintmax_t;     
-
-} // namespace boost
-
-#elif defined(__FreeBSD__) && (__FreeBSD__ <= 4) || defined(__osf__) || defined(__VMS)
-// FreeBSD and Tru64 have an <inttypes.h> that contains much of what we need.
-# include <inttypes.h>
-
-namespace boost {
-
-  using ::int8_t;             
-  typedef int8_t int_least8_t;       
-  typedef int8_t int_fast8_t;        
-  using ::uint8_t;            
-  typedef uint8_t uint_least8_t;      
-  typedef uint8_t uint_fast8_t;       
-                     
-  using ::int16_t;            
-  typedef int16_t int_least16_t;      
-  typedef int16_t int_fast16_t;       
-  using ::uint16_t;           
-  typedef uint16_t uint_least16_t;     
-  typedef uint16_t uint_fast16_t;      
-                     
-  using ::int32_t;            
-  typedef int32_t int_least32_t;      
-  typedef int32_t int_fast32_t;       
-  using ::uint32_t;           
-  typedef uint32_t uint_least32_t;     
-  typedef uint32_t uint_fast32_t;      
-         
-# ifndef BOOST_NO_INT64_T          
-
-  using ::int64_t;            
-  typedef int64_t int_least64_t;      
-  typedef int64_t int_fast64_t;       
-  using ::uint64_t;           
-  typedef uint64_t uint_least64_t;     
-  typedef uint64_t uint_fast64_t;      
-
-  typedef int64_t intmax_t;
-  typedef uint64_t uintmax_t;
-
-# else
-
-  typedef int32_t intmax_t;
-  typedef uint32_t uintmax_t;
-
-# endif
-
-} // namespace boost
-
-#else  // BOOST_HAS_STDINT_H
-
-# include <boost/limits.hpp> // implementation artifact; not part of interface
-# include <limits.h>         // needed for limits macros
-
-
-namespace boost
-{
-
-//  These are fairly safe guesses for some 16-bit, and most 32-bit and 64-bit
-//  platforms.  For other systems, they will have to be hand tailored.
-//
-//  Because the fast types are assumed to be the same as the undecorated types,
-//  it may be possible to hand tailor a more efficient implementation.  Such
-//  an optimization may be illusionary; on the Intel x86-family 386 on, for
-//  example, byte arithmetic and load/stores are as fast as "int" sized ones.
-
-//  8-bit types  ------------------------------------------------------------//
-
-# if UCHAR_MAX == 0xff
-     typedef signed char     int8_t;
-     typedef signed char     int_least8_t;
-     typedef signed char     int_fast8_t;
-     typedef unsigned char   uint8_t;
-     typedef unsigned char   uint_least8_t;
-     typedef unsigned char   uint_fast8_t;
-# else
-#    error defaults not correct; you must hand modify boost/cstdint.hpp
-# endif
-
-//  16-bit types  -----------------------------------------------------------//
-
-# if USHRT_MAX == 0xffff
-#  if defined(__crayx1)
-     // The Cray X1 has a 16-bit short, however it is not recommend
-     // for use in performance critical code.
-     typedef short           int16_t;
-     typedef short           int_least16_t;
-     typedef int             int_fast16_t;
-     typedef unsigned short  uint16_t;
-     typedef unsigned short  uint_least16_t;
-     typedef unsigned int    uint_fast16_t;
-#  else
-     typedef short           int16_t;
-     typedef short           int_least16_t;
-     typedef short           int_fast16_t;
-     typedef unsigned short  uint16_t;
-     typedef unsigned short  uint_least16_t;
-     typedef unsigned short  uint_fast16_t;
-#  endif
-# elif (USHRT_MAX == 0xffffffff) && defined(__MTA__) 
-      // On MTA / XMT short is 32 bits unless the -short16 compiler flag is specified 
-      // MTA / XMT does support the following non-standard integer types 
-      typedef __short16           int16_t; 
-      typedef __short16           int_least16_t; 
-      typedef __short16           int_fast16_t; 
-      typedef unsigned __short16  uint16_t; 
-      typedef unsigned __short16  uint_least16_t; 
-      typedef unsigned __short16  uint_fast16_t; 
-# elif (USHRT_MAX == 0xffffffff) && defined(CRAY)
-     // no 16-bit types on Cray:
-     typedef short           int_least16_t;
-     typedef short           int_fast16_t;
-     typedef unsigned short  uint_least16_t;
-     typedef unsigned short  uint_fast16_t;
-# else
-#    error defaults not correct; you must hand modify boost/cstdint.hpp
-# endif
-
-//  32-bit types  -----------------------------------------------------------//
-
-# if UINT_MAX == 0xffffffff
-     typedef int             int32_t;
-     typedef int             int_least32_t;
-     typedef int             int_fast32_t;
-     typedef unsigned int    uint32_t;
-     typedef unsigned int    uint_least32_t;
-     typedef unsigned int    uint_fast32_t;
-# elif (USHRT_MAX == 0xffffffff)
-     typedef short             int32_t;
-     typedef short             int_least32_t;
-     typedef short             int_fast32_t;
-     typedef unsigned short    uint32_t;
-     typedef unsigned short    uint_least32_t;
-     typedef unsigned short    uint_fast32_t;
-# elif ULONG_MAX == 0xffffffff
-     typedef long            int32_t;
-     typedef long            int_least32_t;
-     typedef long            int_fast32_t;
-     typedef unsigned long   uint32_t;
-     typedef unsigned long   uint_least32_t;
-     typedef unsigned long   uint_fast32_t;
-# elif (UINT_MAX == 0xffffffffffffffff) && defined(__MTA__) 
-      // Integers are 64 bits on the MTA / XMT 
-      typedef __int32           int32_t; 
-      typedef __int32           int_least32_t; 
-      typedef __int32           int_fast32_t; 
-      typedef unsigned __int32  uint32_t; 
-      typedef unsigned __int32  uint_least32_t; 
-      typedef unsigned __int32  uint_fast32_t; 
-# else
-#    error defaults not correct; you must hand modify boost/cstdint.hpp
-# endif
-
-//  64-bit types + intmax_t and uintmax_t  ----------------------------------//
-
-# if defined(BOOST_HAS_LONG_LONG) && \
-   !defined(BOOST_MSVC) && !defined(__BORLANDC__) && \
-   (!defined(__GLIBCPP__) || defined(_GLIBCPP_USE_LONG_LONG)) && \
-   (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX))
-#    if defined(__hpux)
-     // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions
-#    elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615ULL) || (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615ULL) || (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615ULL)
-                                                                 // 2**64 - 1
-#    else
-#       error defaults not correct; you must hand modify boost/cstdint.hpp
-#    endif
-
-     typedef  ::boost::long_long_type            intmax_t;
-     typedef  ::boost::ulong_long_type   uintmax_t;
-     typedef  ::boost::long_long_type            int64_t;
-     typedef  ::boost::long_long_type            int_least64_t;
-     typedef  ::boost::long_long_type            int_fast64_t;
-     typedef  ::boost::ulong_long_type   uint64_t;
-     typedef  ::boost::ulong_long_type   uint_least64_t;
-     typedef  ::boost::ulong_long_type   uint_fast64_t;
-
-# elif ULONG_MAX != 0xffffffff
-
-#    if ULONG_MAX == 18446744073709551615 // 2**64 - 1
-     typedef long                 intmax_t;
-     typedef unsigned long        uintmax_t;
-     typedef long                 int64_t;
-     typedef long                 int_least64_t;
-     typedef long                 int_fast64_t;
-     typedef unsigned long        uint64_t;
-     typedef unsigned long        uint_least64_t;
-     typedef unsigned long        uint_fast64_t;
-#    else
-#       error defaults not correct; you must hand modify boost/cstdint.hpp
-#    endif
-# elif defined(__GNUC__) && defined(BOOST_HAS_LONG_LONG)
-     __extension__ typedef long long            intmax_t;
-     __extension__ typedef unsigned long long   uintmax_t;
-     __extension__ typedef long long            int64_t;
-     __extension__ typedef long long            int_least64_t;
-     __extension__ typedef long long            int_fast64_t;
-     __extension__ typedef unsigned long long   uint64_t;
-     __extension__ typedef unsigned long long   uint_least64_t;
-     __extension__ typedef unsigned long long   uint_fast64_t;
-# elif defined(BOOST_HAS_MS_INT64)
-     //
-     // we have Borland/Intel/Microsoft __int64:
-     //
-     typedef __int64             intmax_t;
-     typedef unsigned __int64    uintmax_t;
-     typedef __int64             int64_t;
-     typedef __int64             int_least64_t;
-     typedef __int64             int_fast64_t;
-     typedef unsigned __int64    uint64_t;
-     typedef unsigned __int64    uint_least64_t;
-     typedef unsigned __int64    uint_fast64_t;
-# else // assume no 64-bit integers
-#  define BOOST_NO_INT64_T
-     typedef int32_t              intmax_t;
-     typedef uint32_t             uintmax_t;
-# endif
-
-} // namespace boost
-
-
-#endif // BOOST_HAS_STDINT_H
-
-#endif // BOOST_CSTDINT_HPP
-
-
-/****************************************************
-
-Macro definition section:
-
-Added 23rd September 2000 (John Maddock).
-Modified 11th September 2001 to be excluded when
-BOOST_HAS_STDINT_H is defined (John Maddock).
-Modified 11th Dec 2009 to always define the
-INT#_C macros if they're not already defined (John Maddock).
-
-******************************************************/
-
-#if !defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && \
-   (!defined(INT8_C) || !defined(INT16_C) || !defined(INT32_C) || !defined(INT64_C))
-//
-// For the following code we get several warnings along the lines of: 
-// 
-// boost/cstdint.hpp:428:35: error: use of C99 long long integer constant 
-// 
-// So we declare this a system header to suppress these warnings. 
-//
-#if defined(__GNUC__) && (__GNUC__ >= 4) 
-#pragma GCC system_header 
-#endif 
-
-#include <limits.h>
-# define BOOST__STDC_CONSTANT_MACROS_DEFINED
-# if defined(BOOST_HAS_MS_INT64)
-//
-// Borland/Intel/Microsoft compilers have width specific suffixes:
-//
-#ifndef INT8_C
-#  define INT8_C(value)     value##i8
-#endif
-#ifndef INT16_C
-#  define INT16_C(value)    value##i16
-#endif
-#ifndef INT32_C
-#  define INT32_C(value)    value##i32
-#endif
-#ifndef INT64_C
-#  define INT64_C(value)    value##i64
-#endif
-#  ifdef __BORLANDC__
-    // Borland bug: appending ui8 makes the type a signed char
-#   define UINT8_C(value)    static_cast<unsigned char>(value##u)
-#  else
-#   define UINT8_C(value)    value##ui8
-#  endif
-#ifndef UINT16_C
-#  define UINT16_C(value)   value##ui16
-#endif
-#ifndef UINT32_C
-#  define UINT32_C(value)   value##ui32
-#endif
-#ifndef UINT64_C
-#  define UINT64_C(value)   value##ui64
-#endif
-#ifndef INTMAX_C
-#  define INTMAX_C(value)   value##i64
-#  define UINTMAX_C(value)  value##ui64
-#endif
-
-# else
-//  do it the old fashioned way:
-
-//  8-bit types  ------------------------------------------------------------//
-
-#  if (UCHAR_MAX == 0xff) && !defined(INT8_C)
-#   define INT8_C(value) static_cast<boost::int8_t>(value)
-#   define UINT8_C(value) static_cast<boost::uint8_t>(value##u)
-#  endif
-
-//  16-bit types  -----------------------------------------------------------//
-
-#  if (USHRT_MAX == 0xffff) && !defined(INT16_C)
-#   define INT16_C(value) static_cast<boost::int16_t>(value)
-#   define UINT16_C(value) static_cast<boost::uint16_t>(value##u)
-#  endif
-
-//  32-bit types  -----------------------------------------------------------//
-#ifndef INT32_C
-#  if (UINT_MAX == 0xffffffff)
-#   define INT32_C(value) value
-#   define UINT32_C(value) value##u
-#  elif ULONG_MAX == 0xffffffff
-#   define INT32_C(value) value##L
-#   define UINT32_C(value) value##uL
-#  endif
-#endif
-
-//  64-bit types + intmax_t and uintmax_t  ----------------------------------//
-#ifndef INT64_C
-#  if defined(BOOST_HAS_LONG_LONG) && \
-    (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX) || defined(_LLONG_MAX))
-
-#    if defined(__hpux)
-        // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions
-#       define INT64_C(value) value##LL
-#       define UINT64_C(value) value##uLL
-#    elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615ULL) ||  \
-        (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615ULL) ||  \
-        (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615ULL) || \
-        (defined(_LLONG_MAX) && _LLONG_MAX == 18446744073709551615ULL)
-
-#       define INT64_C(value) value##LL
-#       define UINT64_C(value) value##uLL
-#    else
-#       error defaults not correct; you must hand modify boost/cstdint.hpp
-#    endif
-#  elif ULONG_MAX != 0xffffffff
-
-#    if ULONG_MAX == 18446744073709551615U // 2**64 - 1
-#       define INT64_C(value) value##L
-#       define UINT64_C(value) value##uL
-#    else
-#       error defaults not correct; you must hand modify boost/cstdint.hpp
-#    endif
-#  elif defined(BOOST_HAS_LONG_LONG)
-     // Usual macros not defined, work things out for ourselves:
-#    if(~0uLL == 18446744073709551615ULL)
-#       define INT64_C(value) value##LL
-#       define UINT64_C(value) value##uLL
-#    else
-#       error defaults not correct; you must hand modify boost/cstdint.hpp
-#    endif
-#  else
-#    error defaults not correct; you must hand modify boost/cstdint.hpp
-#  endif
-
-#  ifdef BOOST_NO_INT64_T
-#   define INTMAX_C(value) INT32_C(value)
-#   define UINTMAX_C(value) UINT32_C(value)
-#  else
-#   define INTMAX_C(value) INT64_C(value)
-#   define UINTMAX_C(value) UINT64_C(value)
-#  endif
-#endif
-# endif // Borland/Microsoft specific width suffixes
-
-#endif // INT#_C macros.
-
-
-
-

include/boost/integer.hpp

@@ -2,9 +2,9 @@
 
 //  Copyright Beman Dawes and Daryle Walker 1999.  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)
+//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/libs/integer for documentation.
+//  See https://www.boost.org/libs/integer for documentation.
 
 //  Revision History
 //   22 Sep 01  Added value-based integer templates. (Daryle Walker)
@@ -20,6 +20,7 @@
 #include <boost/integer_traits.hpp>  // for boost::::boost::integer_traits
 #include <boost/limits.hpp>          // for ::std::numeric_limits
 #include <boost/cstdint.hpp>         // for boost::int64_t and BOOST_NO_INTEGRAL_INT64_T
+#include <boost/static_assert.hpp>
 
 //
 // We simply cannot include this header on gcc without getting copious warnings of the kind:
@@ -41,16 +42,17 @@ namespace boost
   //  fast integers from least integers
   //  int_fast_t<> works correctly for unsigned too, in spite of the name.
   template< typename LeastInt >
-  struct int_fast_t 
+  struct int_fast_t
-  { 
+  {
-     typedef LeastInt fast; 
+     typedef LeastInt fast;
      typedef fast     type;
   }; // imps may specialize
 
   namespace detail{
 
-  //  convert category to type 
+  //  convert category to type
   template< int Category > struct int_least_helper {}; // default is empty
+  template< int Category > struct uint_least_helper {}; // default is empty
 
   //  specializatons: 1=long, 2=int, 3=short, 4=signed char,
   //     6=unsigned long, 7=unsigned int, 8=unsigned short, 9=unsigned char
@@ -65,14 +67,14 @@ namespace boost
   template<> struct int_least_helper<4> { typedef short least; };
   template<> struct int_least_helper<5> { typedef signed char least; };
 #ifdef BOOST_HAS_LONG_LONG
-  template<> struct int_least_helper<6> { typedef boost::ulong_long_type least; };
+  template<> struct uint_least_helper<1> { typedef boost::ulong_long_type least; };
 #elif defined(BOOST_HAS_MS_INT64)
-  template<> struct int_least_helper<6> { typedef unsigned __int64 least; };
+  template<> struct uint_least_helper<1> { typedef unsigned __int64 least; };
 #endif
-  template<> struct int_least_helper<7> { typedef unsigned long least; };
+  template<> struct uint_least_helper<2> { typedef unsigned long least; };
-  template<> struct int_least_helper<8> { typedef unsigned int least; };
+  template<> struct uint_least_helper<3> { typedef unsigned int least; };
-  template<> struct int_least_helper<9> { typedef unsigned short least; };
+  template<> struct uint_least_helper<4> { typedef unsigned short least; };
-  template<> struct int_least_helper<10> { typedef unsigned char least; };
+  template<> struct uint_least_helper<5> { typedef unsigned char least; };
 
   template <int Bits>
   struct exact_signed_base_helper{};
@@ -89,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
@@ -109,9 +112,11 @@ namespace boost
 
   //  signed
   template< int Bits >   // bits (including sign) required
-  struct int_t : public detail::exact_signed_base_helper<Bits>
+  struct int_t : public boost::detail::exact_signed_base_helper<Bits>
   {
-      typedef typename detail::int_least_helper
+      BOOST_STATIC_ASSERT_MSG(Bits <= (int)(sizeof(boost::intmax_t) * CHAR_BIT),
+         "No suitable signed integer type with the requested number of bits is available.");
+      typedef typename boost::detail::int_least_helper
         <
 #ifdef BOOST_HAS_LONG_LONG
           (Bits <= (int)(sizeof(boost::long_long_type) * CHAR_BIT)) +
@@ -128,11 +133,13 @@ namespace boost
 
   //  unsigned
   template< int Bits >   // bits required
-  struct uint_t : public detail::exact_unsigned_base_helper<Bits>
+  struct uint_t : public boost::detail::exact_unsigned_base_helper<Bits>
   {
-#if (defined(__BORLANDC__) || defined(__CODEGEAR__)) && defined(BOOST_NO_INTEGRAL_INT64_T)
+     BOOST_STATIC_ASSERT_MSG(Bits <= (int)(sizeof(boost::uintmax_t) * CHAR_BIT),
+         "No suitable unsigned integer type with the requested number of bits is available.");
+#if (defined(BOOST_BORLANDC) || defined(__CODEGEAR__)) && defined(BOOST_NO_INTEGRAL_INT64_T)
      // It's really not clear why this workaround should be needed... shrug I guess!  JM
-     BOOST_STATIC_CONSTANT(int, s = 
+     BOOST_STATIC_CONSTANT(int, s =
            6 +
           (Bits <= ::std::numeric_limits<unsigned long>::digits) +
           (Bits <= ::std::numeric_limits<unsigned int>::digits) +
@@ -140,9 +147,8 @@ namespace boost
           (Bits <= ::std::numeric_limits<unsigned char>::digits));
      typedef typename detail::int_least_helper< ::boost::uint_t<Bits>::s>::least least;
 #else
-      typedef typename detail::int_least_helper
+      typedef typename boost::detail::uint_least_helper
-        < 
+        <
-          5 +
 #ifdef BOOST_HAS_LONG_LONG
           (Bits <= (int)(sizeof(boost::long_long_type) * CHAR_BIT)) +
 #else
@@ -161,16 +167,16 @@ 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
 #endif
-  struct int_max_value_t 
+  struct int_max_value_t
   {
-      typedef typename detail::int_least_helper
+      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 +
@@ -183,16 +189,16 @@ 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
 #endif
-  struct int_min_value_t 
+  struct int_min_value_t
   {
-      typedef typename detail::int_least_helper
+      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 +
@@ -211,32 +217,31 @@ namespace boost
 #else
   template< unsigned long MaxValue >   // minimum value to require support
 #endif
-  struct uint_value_t 
+  struct uint_value_t
   {
-#if (defined(__BORLANDC__) || defined(__CODEGEAR__))
+#if (defined(BOOST_BORLANDC) || defined(__CODEGEAR__))
      // It's really not clear why this workaround should be needed... shrug I guess!  JM
 #if defined(BOOST_NO_INTEGRAL_INT64_T)
-      BOOST_STATIC_CONSTANT(unsigned, which = 
+      BOOST_STATIC_CONSTANT(unsigned, which =
-           6 +
+           1 +
           (MaxValue <= ::boost::integer_traits<unsigned long>::const_max) +
           (MaxValue <= ::boost::integer_traits<unsigned int>::const_max) +
           (MaxValue <= ::boost::integer_traits<unsigned short>::const_max) +
           (MaxValue <= ::boost::integer_traits<unsigned char>::const_max));
       typedef typename detail::int_least_helper< ::boost::uint_value_t<MaxValue>::which>::least least;
 #else // BOOST_NO_INTEGRAL_INT64_T
-      BOOST_STATIC_CONSTANT(unsigned, which = 
+      BOOST_STATIC_CONSTANT(unsigned, which =
-           5 +
+           1 +
           (MaxValue <= ::boost::integer_traits<boost::ulong_long_type>::const_max) +
           (MaxValue <= ::boost::integer_traits<unsigned long>::const_max) +
           (MaxValue <= ::boost::integer_traits<unsigned int>::const_max) +
           (MaxValue <= ::boost::integer_traits<unsigned short>::const_max) +
           (MaxValue <= ::boost::integer_traits<unsigned char>::const_max));
-      typedef typename detail::int_least_helper< ::boost::uint_value_t<MaxValue>::which>::least least;
+      typedef typename detail::uint_least_helper< ::boost::uint_value_t<MaxValue>::which>::least least;
 #endif // BOOST_NO_INTEGRAL_INT64_T
 #else
-      typedef typename detail::int_least_helper
+      typedef typename boost::detail::uint_least_helper
-        < 
+        <
-          5 +
 #if !defined(BOOST_NO_INTEGRAL_INT64_T) && defined(BOOST_HAS_LONG_LONG)
           (MaxValue <= ::boost::integer_traits<boost::ulong_long_type>::const_max) +
 #else

include/boost/integer/common_factor.hpp

@@ -0,0 +1,16 @@
+//  Boost common_factor.hpp header file  -------------------------------------//
+
+//  (C) Copyright Daryle Walker 2001-2002.
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  https://www.boost.org/LICENSE_1_0.txt)
+
+//  See https://www.boost.org for updates, documentation, and revision history. 
+
+#ifndef BOOST_INTEGER_COMMON_FACTOR_HPP
+#define BOOST_INTEGER_COMMON_FACTOR_HPP
+
+#include <boost/integer/common_factor_ct.hpp>
+#include <boost/integer/common_factor_rt.hpp>
+
+#endif  // BOOST_INTEGER_COMMON_FACTOR_HPP

include/boost/integer/common_factor_ct.hpp

@@ -0,0 +1,102 @@
+//  Boost common_factor_ct.hpp header file  ----------------------------------//
+
+//  (C) Copyright Daryle Walker and Stephen Cleary 2001-2002.
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  https://www.boost.org/LICENSE_1_0.txt)
+
+//  See https://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>  // self include
+#include <boost/config.hpp>  // for BOOST_STATIC_CONSTANT, etc.
+
+namespace boost
+{
+namespace integer
+{
+
+//  Implementation details  --------------------------------------------------//
+
+namespace detail
+{
+    // Build GCD with Euclid's recursive algorithm
+    template < static_gcd_type Value1, static_gcd_type Value2 >
+    struct static_gcd_helper_t
+    {
+    private:
+        BOOST_STATIC_CONSTANT( static_gcd_type, new_value1 = Value2 );
+        BOOST_STATIC_CONSTANT( static_gcd_type, new_value2 = Value1 % Value2 );
+
+        #ifndef BOOST_BORLANDC
+        #define BOOST_DETAIL_GCD_HELPER_VAL(Value) static_cast<static_gcd_type>(Value)
+        #else
+        typedef static_gcd_helper_t  self_type;
+        #define BOOST_DETAIL_GCD_HELPER_VAL(Value)  (self_type:: Value )
+        #endif
+
+        typedef static_gcd_helper_t< BOOST_DETAIL_GCD_HELPER_VAL(new_value1),
+         BOOST_DETAIL_GCD_HELPER_VAL(new_value2) >  next_step_type;
+
+        #undef BOOST_DETAIL_GCD_HELPER_VAL
+
+    public:
+        BOOST_STATIC_CONSTANT( static_gcd_type, value = next_step_type::value );
+    };
+
+    // Non-recursive case
+    template < static_gcd_type Value1 >
+    struct static_gcd_helper_t< Value1, 0UL >
+    {
+        BOOST_STATIC_CONSTANT( static_gcd_type, value = Value1 );
+    };
+
+    // Build the LCM from the GCD
+    template < static_gcd_type Value1, static_gcd_type Value2 >
+    struct static_lcm_helper_t
+    {
+        typedef static_gcd_helper_t<Value1, Value2>  gcd_type;
+
+        BOOST_STATIC_CONSTANT( static_gcd_type, value = Value1 / gcd_type::value
+         * Value2 );
+    };
+
+    // Special case for zero-GCD values
+    template < >
+    struct static_lcm_helper_t< 0UL, 0UL >
+    {
+        BOOST_STATIC_CONSTANT( static_gcd_type, value = 0UL );
+    };
+
+}  // namespace detail
+
+
+//  Compile-time greatest common divisor evaluator class declaration  --------//
+
+template < static_gcd_type Value1, static_gcd_type Value2 > struct static_gcd
+{
+    BOOST_STATIC_CONSTANT( static_gcd_type, value = (detail::static_gcd_helper_t<Value1, Value2>::value) );
+};  // boost::integer::static_gcd
+
+#if !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)
+template< static_gcd_type Value1, static_gcd_type Value2 > static_gcd_type const static_gcd< Value1, Value2 >::value;
+#endif
+
+//  Compile-time least common multiple evaluator class declaration  ----------//
+
+template < static_gcd_type Value1, static_gcd_type Value2 > struct static_lcm
+{
+    BOOST_STATIC_CONSTANT( static_gcd_type, value = (detail::static_lcm_helper_t<Value1, Value2>::value) );
+};  // boost::integer::static_lcm
+
+#if !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)
+template< static_gcd_type Value1, static_gcd_type Value2 > static_gcd_type const static_lcm< Value1, Value2 >::value;
+#endif
+
+}  // namespace integer
+}  // namespace boost
+
+
+#endif  // BOOST_INTEGER_COMMON_FACTOR_CT_HPP

include/boost/integer/common_factor_rt.hpp

@@ -0,0 +1,580 @@
+//  (C) Copyright Jeremy William Murphy 2016.
+
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_INTEGER_COMMON_FACTOR_RT_HPP
+#define BOOST_INTEGER_COMMON_FACTOR_RT_HPP
+
+#include <boost/assert.hpp>
+#include <boost/core/enable_if.hpp>
+
+#include <boost/config.hpp>  // for BOOST_NESTED_TEMPLATE, etc.
+#include <boost/limits.hpp>  // for std::numeric_limits
+#include <climits>           // for CHAR_MIN
+#include <boost/detail/workaround.hpp>
+#include <iterator>
+#include <algorithm>
+#include <limits>
+#ifndef BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#include <type_traits>
+#endif
+#ifdef BOOST_NO_CXX11_HDR_FUNCTIONAL
+#include <functional>
+#endif
+
+#if ((defined(BOOST_MSVC) && (BOOST_MSVC >= 1600)) || (defined(__clang__) && defined(__c2__)) || (defined(BOOST_INTEL) && defined(_MSC_VER))) && (defined(_M_IX86) || defined(_M_X64))
+#include <intrin.h>
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4127 4244)  // Conditional expression is constant
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) && !defined(BOOST_NO_CXX11_NOEXCEPT)
+#define BOOST_GCD_NOEXCEPT(T) noexcept(std::is_arithmetic<T>::value)
+#else
+#define BOOST_GCD_NOEXCEPT(T)
+#endif
+
+namespace boost {
+
+   template <class I>
+   class rational;
+
+   namespace integer {
+
+      namespace gcd_detail{
+
+         //
+         // some helper functions which really should be constexpr already, but sadly aren't:
+         //
+#ifndef BOOST_NO_CXX14_CONSTEXPR
+         template <class T>
+         inline constexpr T constexpr_min(T const& a, T const& b) BOOST_GCD_NOEXCEPT(T)
+         {
+            return a < b ? a : b;
+         }
+         template <class T>
+         inline constexpr auto constexpr_swap(T&a, T& b) BOOST_GCD_NOEXCEPT(T) -> decltype(a.swap(b))
+         {
+            return a.swap(b);
+         }
+         template <class T, class U>
+         inline constexpr void constexpr_swap(T&a, U& b...) BOOST_GCD_NOEXCEPT(T)
+         {
+            T t(static_cast<T&&>(a));
+            a = static_cast<T&&>(b);
+            b = static_cast<T&&>(t);
+         }
+#else
+         template <class T>
+         inline T constexpr_min(T const& a, T const& b) BOOST_GCD_NOEXCEPT(T)
+         {
+            return a < b ? a : b;
+         }
+         template <class T>
+         inline void constexpr_swap(T&a, T& b) BOOST_GCD_NOEXCEPT(T)
+         {
+            using std::swap;
+            swap(a, b);
+         }
+#endif
+
+      template <class T, bool a =
+#ifndef BOOST_NO_CXX11_HDR_TYPE_TRAITS
+         std::is_unsigned<T>::value ||
+#endif
+         (std::numeric_limits<T>::is_specialized && !std::numeric_limits<T>::is_signed)>
+      struct gcd_traits_abs_defaults
+      {
+         inline static BOOST_CXX14_CONSTEXPR const T& abs(const T& val) BOOST_GCD_NOEXCEPT(T) { return val; }
+      };
+      template <class T>
+      struct gcd_traits_abs_defaults<T, false>
+      {
+         inline static T BOOST_CXX14_CONSTEXPR abs(const T& val) BOOST_GCD_NOEXCEPT(T)
+         {
+            // This sucks, but std::abs is not constexpr :(
+            return val < T(0) ? -val : val;
+         }
+      };
+
+      enum method_type
+      {
+         method_euclid = 0,
+         method_binary = 1,
+         method_mixed = 2
+      };
+
+      struct any_convert
+      {
+         template <class T>
+         any_convert(const T&);
+      };
+
+      struct unlikely_size
+      {
+         char buf[9973];
+      };
+
+      unlikely_size operator <<= (any_convert, any_convert);
+      unlikely_size operator >>= (any_convert, any_convert);
+
+      template <class T>
+      struct gcd_traits_defaults : public gcd_traits_abs_defaults<T>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(T& val) BOOST_GCD_NOEXCEPT(T)
+         {
+            unsigned r = 0;
+            while (T(0) == (val & 1u))
+            {
+#ifdef _MSC_VER  // VC++ can't handle operator >>= in constexpr code for some reason
+               val = val >> 1;
+#else
+               val >>= 1;
+#endif
+               ++r;
+            }
+            return r;
+         }
+         inline static BOOST_CXX14_CONSTEXPR bool less(const T& a, const T& b) BOOST_GCD_NOEXCEPT(T)
+         {
+            return a < b;
+         }
+
+         static T& get_value();
+
+#ifndef BOOST_NO_SFINAE
+         static const bool has_operator_left_shift_equal = sizeof(get_value() <<= 2) != sizeof(unlikely_size);
+         static const bool has_operator_right_shift_equal = sizeof(get_value() >>= 2) != sizeof(unlikely_size);
+#else
+         static const bool has_operator_left_shift_equal = true;
+         static const bool has_operator_right_shift_equal = true;
+#endif
+         static const method_type method = std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::is_integer && has_operator_left_shift_equal && has_operator_right_shift_equal ? method_mixed : method_euclid;
+      };
+      //
+      // Default gcd_traits just inherits from defaults:
+      //
+      template <class T>
+      struct gcd_traits : public gcd_traits_defaults<T> {};
+
+      //
+      // Some platforms have fast bitscan operations, that allow us to implement
+      // make_odd much more efficiently, unfortunately we can't use these if we want
+      // the functions to be constexpr as the compiler intrinsics aren't constexpr.
+      //
+#if defined(BOOST_NO_CXX14_CONSTEXPR) && ((defined(BOOST_MSVC) && (BOOST_MSVC >= 1600)) || (defined(__clang__) && defined(__c2__)) || (defined(BOOST_INTEL) && defined(_MSC_VER))) && (defined(_M_IX86) || defined(_M_X64))
+#pragma intrinsic(_BitScanForward,)
+      template <>
+      struct gcd_traits<unsigned long> : public gcd_traits_defaults<unsigned long>
+      {
+         BOOST_FORCEINLINE static unsigned find_lsb(unsigned long val) BOOST_NOEXCEPT
+         {
+            unsigned long result;
+            _BitScanForward(&result, val);
+            return result;
+         }
+         BOOST_FORCEINLINE static unsigned make_odd(unsigned long& val) BOOST_NOEXCEPT
+         {
+            unsigned result = find_lsb(val);
+            val >>= result;
+            return result;
+         }
+      };
+
+#ifdef _M_X64
+#pragma intrinsic(_BitScanForward64)
+      template <>
+      struct gcd_traits<unsigned __int64> : public gcd_traits_defaults<unsigned __int64>
+      {
+         BOOST_FORCEINLINE static unsigned find_lsb(unsigned __int64 mask) BOOST_NOEXCEPT
+         {
+            unsigned long result;
+            _BitScanForward64(&result, mask);
+            return result;
+         }
+         BOOST_FORCEINLINE static unsigned make_odd(unsigned __int64& val) BOOST_NOEXCEPT
+         {
+            unsigned result = find_lsb(val);
+            val >>= result;
+            return result;
+         }
+      };
+#endif
+      //
+      // Other integer type are trivial adaptations of the above,
+      // this works for signed types too, as by the time these functions
+      // are called, all values are > 0.
+      //
+      template <> struct gcd_traits<long> : public gcd_traits_defaults<long>
+      { BOOST_FORCEINLINE static unsigned make_odd(long& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
+      template <> struct gcd_traits<unsigned int> : public gcd_traits_defaults<unsigned int>
+      { BOOST_FORCEINLINE static unsigned make_odd(unsigned int& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
+      template <> struct gcd_traits<int> : public gcd_traits_defaults<int>
+      { BOOST_FORCEINLINE static unsigned make_odd(int& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
+      template <> struct gcd_traits<unsigned short> : public gcd_traits_defaults<unsigned short>
+      { BOOST_FORCEINLINE static unsigned make_odd(unsigned short& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
+      template <> struct gcd_traits<short> : public gcd_traits_defaults<short>
+      { BOOST_FORCEINLINE static unsigned make_odd(short& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
+      template <> struct gcd_traits<unsigned char> : public gcd_traits_defaults<unsigned char>
+      { BOOST_FORCEINLINE static unsigned make_odd(unsigned char& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
+      template <> struct gcd_traits<signed char> : public gcd_traits_defaults<signed char>
+      { BOOST_FORCEINLINE static unsigned make_odd(signed char& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
+      template <> struct gcd_traits<char> : public gcd_traits_defaults<char>
+      { BOOST_FORCEINLINE static unsigned make_odd(char& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+      template <> struct gcd_traits<wchar_t> : public gcd_traits_defaults<wchar_t>
+      { BOOST_FORCEINLINE static unsigned make_odd(wchar_t& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
+#endif
+#ifdef _M_X64
+      template <> struct gcd_traits<__int64> : public gcd_traits_defaults<__int64>
+      { BOOST_FORCEINLINE static unsigned make_odd(__int64& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned __int64>::find_lsb(val); val >>= result; return result; } };
+#endif
+
+#elif defined(BOOST_GCC) || defined(__clang__) || (defined(BOOST_INTEL) && defined(__GNUC__))
+
+      template <>
+      struct gcd_traits<unsigned> : public gcd_traits_defaults<unsigned>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned find_lsb(unsigned mask)BOOST_NOEXCEPT
+         {
+            return __builtin_ctz(mask);
+         }
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(unsigned& val)BOOST_NOEXCEPT
+         {
+            unsigned result = find_lsb(val);
+            val >>= result;
+            return result;
+         }
+      };
+      template <>
+      struct gcd_traits<unsigned long> : public gcd_traits_defaults<unsigned long>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned find_lsb(unsigned long mask)BOOST_NOEXCEPT
+         {
+            return __builtin_ctzl(mask);
+         }
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(unsigned long& val)BOOST_NOEXCEPT
+         {
+            unsigned result = find_lsb(val);
+            val >>= result;
+            return result;
+         }
+      };
+      template <>
+      struct gcd_traits<boost::ulong_long_type> : public gcd_traits_defaults<boost::ulong_long_type>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned find_lsb(boost::ulong_long_type mask)BOOST_NOEXCEPT
+         {
+            return __builtin_ctzll(mask);
+         }
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(boost::ulong_long_type& val)BOOST_NOEXCEPT
+         {
+            unsigned result = find_lsb(val);
+            val >>= result;
+            return result;
+         }
+      };
+      //
+      // Other integer type are trivial adaptations of the above,
+      // this works for signed types too, as by the time these functions
+      // are called, all values are > 0.
+      //
+      template <> struct gcd_traits<boost::long_long_type> : public gcd_traits_defaults<boost::long_long_type>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(boost::long_long_type& val)BOOST_NOEXCEPT { unsigned result = gcd_traits<boost::ulong_long_type>::find_lsb(val); val >>= result; return result; }
+      };
+      template <> struct gcd_traits<long> : public gcd_traits_defaults<long>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(long& val)BOOST_NOEXCEPT { unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; }
+      };
+      template <> struct gcd_traits<int> : public gcd_traits_defaults<int>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(int& val)BOOST_NOEXCEPT { unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; }
+      };
+      template <> struct gcd_traits<unsigned short> : public gcd_traits_defaults<unsigned short>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(unsigned short& val)BOOST_NOEXCEPT { unsigned result = gcd_traits<unsigned>::find_lsb(val); val >>= result; return result; }
+      };
+      template <> struct gcd_traits<short> : public gcd_traits_defaults<short>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(short& val)BOOST_NOEXCEPT { unsigned result = gcd_traits<unsigned>::find_lsb(val); val >>= result; return result; }
+      };
+      template <> struct gcd_traits<unsigned char> : public gcd_traits_defaults<unsigned char>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(unsigned char& val)BOOST_NOEXCEPT { unsigned result = gcd_traits<unsigned>::find_lsb(val); val >>= result; return result; }
+      };
+      template <> struct gcd_traits<signed char> : public gcd_traits_defaults<signed char>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(signed char& val)BOOST_NOEXCEPT { unsigned result = gcd_traits<unsigned>::find_lsb(val); val >>= result; return result; }
+      };
+      template <> struct gcd_traits<char> : public gcd_traits_defaults<char>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(char& val)BOOST_NOEXCEPT { unsigned result = gcd_traits<unsigned>::find_lsb(val); val >>= result; return result; }
+      };
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+      template <> struct gcd_traits<wchar_t> : public gcd_traits_defaults<wchar_t>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(wchar_t& val)BOOST_NOEXCEPT { unsigned result = gcd_traits<unsigned>::find_lsb(val); val >>= result; return result; }
+      };
+#endif
+#endif
+   //
+   // The Mixed Binary Euclid Algorithm
+   // Sidi Mohamed Sedjelmaci
+   // Electronic Notes in Discrete Mathematics 35 (2009) 169-176
+   //
+   template <class T>
+   BOOST_CXX14_CONSTEXPR T mixed_binary_gcd(T u, T v) BOOST_GCD_NOEXCEPT(T)
+   {
+      if(gcd_traits<T>::less(u, v))
+         constexpr_swap(u, v);
+
+      unsigned shifts = 0;
+
+      if(u == T(0))
+         return v;
+      if(v == T(0))
+         return u;
+
+      shifts = constexpr_min(gcd_traits<T>::make_odd(u), gcd_traits<T>::make_odd(v));
+
+      while(gcd_traits<T>::less(1, v))
+      {
+         u %= v;
+         v -= u;
+         if(u == T(0))
+            return v << shifts;
+         if(v == T(0))
+            return u << shifts;
+         gcd_traits<T>::make_odd(u);
+         gcd_traits<T>::make_odd(v);
+         if(gcd_traits<T>::less(u, v))
+            constexpr_swap(u, v);
+      }
+      return (v == 1 ? v : u) << shifts;
+   }
+
+    /** Stein gcd (aka 'binary gcd')
+     *
+     * From Mathematics to Generic Programming, Alexander Stepanov, Daniel Rose
+     */
+    template <typename SteinDomain>
+    BOOST_CXX14_CONSTEXPR SteinDomain Stein_gcd(SteinDomain m, SteinDomain n) BOOST_GCD_NOEXCEPT(SteinDomain)
+    {
+        BOOST_ASSERT(m >= 0);
+        BOOST_ASSERT(n >= 0);
+        if (m == SteinDomain(0))
+            return n;
+        if (n == SteinDomain(0))
+            return m;
+        // m > 0 && n > 0
+        unsigned d_m = gcd_traits<SteinDomain>::make_odd(m);
+        unsigned d_n = gcd_traits<SteinDomain>::make_odd(n);
+        // odd(m) && odd(n)
+        while (m != n)
+        {
+            if (n > m)
+               constexpr_swap(n, m);
+            m -= n;
+            gcd_traits<SteinDomain>::make_odd(m);
+        }
+        // m == n
+        m <<= constexpr_min(d_m, d_n);
+        return m;
+    }
+
+
+    /** Euclidean algorithm
+     *
+     * From Mathematics to Generic Programming, Alexander Stepanov, Daniel Rose
+     *
+     */
+    template <typename EuclideanDomain>
+    inline BOOST_CXX14_CONSTEXPR EuclideanDomain Euclid_gcd(EuclideanDomain a, EuclideanDomain b) BOOST_GCD_NOEXCEPT(EuclideanDomain)
+    {
+        while (b != EuclideanDomain(0))
+        {
+            a %= b;
+            constexpr_swap(a, b);
+        }
+        return a;
+    }
+
+
+    template <typename T>
+    inline BOOST_CXX14_CONSTEXPR BOOST_DEDUCED_TYPENAME enable_if_c<gcd_traits<T>::method == method_mixed, T>::type
+       optimal_gcd_select(T const &a, T const &b) BOOST_GCD_NOEXCEPT(T)
+    {
+       return gcd_detail::mixed_binary_gcd(a, b);
+    }
+
+    template <typename T>
+    inline BOOST_CXX14_CONSTEXPR BOOST_DEDUCED_TYPENAME enable_if_c<gcd_traits<T>::method == method_binary, T>::type
+       optimal_gcd_select(T const &a, T const &b) BOOST_GCD_NOEXCEPT(T)
+    {
+       return gcd_detail::Stein_gcd(a, b);
+    }
+
+    template <typename T>
+    inline BOOST_CXX14_CONSTEXPR BOOST_DEDUCED_TYPENAME enable_if_c<gcd_traits<T>::method == method_euclid, T>::type
+       optimal_gcd_select(T const &a, T const &b) BOOST_GCD_NOEXCEPT(T)
+    {
+       return gcd_detail::Euclid_gcd(a, b);
+    }
+
+    template <class T>
+    inline BOOST_CXX14_CONSTEXPR T lcm_imp(const T& a, const T& b) BOOST_GCD_NOEXCEPT(T)
+    {
+       T temp = boost::integer::gcd_detail::optimal_gcd_select(a, b);
+#if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40500)
+       return (temp != T(0)) ? T(a / temp * b) : T(0);
+#else
+       return temp != T(0) ? T(a / temp * b) : T(0);
+#endif
+    }
+
+} // namespace detail
+
+
+template <typename Integer>
+inline BOOST_CXX14_CONSTEXPR Integer gcd(Integer const &a, Integer const &b) BOOST_GCD_NOEXCEPT(Integer)
+{
+    if(a == (std::numeric_limits<Integer>::min)())
+       return a == static_cast<Integer>(0) ? gcd_detail::gcd_traits<Integer>::abs(b) : boost::integer::gcd(static_cast<Integer>(a % b), b);
+    else if (b == (std::numeric_limits<Integer>::min)())
+       return b == static_cast<Integer>(0) ? gcd_detail::gcd_traits<Integer>::abs(a) : boost::integer::gcd(a, static_cast<Integer>(b % a));
+    return gcd_detail::optimal_gcd_select(static_cast<Integer>(gcd_detail::gcd_traits<Integer>::abs(a)), static_cast<Integer>(gcd_detail::gcd_traits<Integer>::abs(b)));
+}
+
+template <typename Integer>
+inline BOOST_CXX14_CONSTEXPR Integer lcm(Integer const &a, Integer const &b) BOOST_GCD_NOEXCEPT(Integer)
+{
+   return gcd_detail::lcm_imp(static_cast<Integer>(gcd_detail::gcd_traits<Integer>::abs(a)), static_cast<Integer>(gcd_detail::gcd_traits<Integer>::abs(b)));
+}
+#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+//
+// This looks slightly odd, but the variadic forms must have 3 or more arguments, and the variadic argument pack may be empty.
+// This matters not at all for most compilers, but Oracle C++ selects the wrong overload in the 2-arg case unless we do this.
+//
+template <typename Integer, typename... Args>
+inline BOOST_CXX14_CONSTEXPR Integer gcd(Integer const &a, Integer const &b, const Integer& c, Args const&... args) BOOST_GCD_NOEXCEPT(Integer)
+{
+   Integer t = gcd(b, c, args...);
+   return t == 1 ? 1 : gcd(a, t);
+}
+
+template <typename Integer, typename... Args>
+inline BOOST_CXX14_CONSTEXPR Integer lcm(Integer const &a, Integer const &b, Integer const& c, Args const&... args) BOOST_GCD_NOEXCEPT(Integer)
+{
+   return lcm(a, lcm(b, c, args...));
+}
+#endif
+//
+// Special handling for rationals:
+//
+template <typename Integer>
+inline typename boost::enable_if_c<std::numeric_limits<Integer>::is_specialized, boost::rational<Integer> >::type gcd(boost::rational<Integer> const &a, boost::rational<Integer> const &b)
+{
+   return boost::rational<Integer>(static_cast<Integer>(gcd(a.numerator(), b.numerator())), static_cast<Integer>(lcm(a.denominator(), b.denominator())));
+}
+
+template <typename Integer>
+inline typename boost::enable_if_c<std::numeric_limits<Integer>::is_specialized, boost::rational<Integer> >::type lcm(boost::rational<Integer> const &a, boost::rational<Integer> const &b)
+{
+   return boost::rational<Integer>(static_cast<Integer>(lcm(a.numerator(), b.numerator())), static_cast<Integer>(gcd(a.denominator(), b.denominator())));
+}
+/**
+ * Knuth, The Art of Computer Programming: Volume 2, Third edition, 1998
+ * Chapter 4.5.2, Algorithm C: Greatest common divisor of n integers.
+ *
+ * Knuth counts down from n to zero but we naturally go from first to last.
+ * We also return the termination position because it might be useful to know.
+ *
+ * Partly by quirk, partly by design, this algorithm is defined for n = 1,
+ * because the gcd of {x} is x. It is not defined for n = 0.
+ *
+ * @tparam  I   Input iterator.
+ * @return  The gcd of the range and the iterator position at termination.
+ */
+template <typename I>
+std::pair<typename std::iterator_traits<I>::value_type, I>
+gcd_range(I first, I last) BOOST_GCD_NOEXCEPT(I)
+{
+    BOOST_ASSERT(first != last);
+    typedef typename std::iterator_traits<I>::value_type T;
+
+    T d = *first;
+    ++first;
+    while (d != T(1) && first != last)
+    {
+        d = gcd(d, *first);
+        ++first;
+    }
+    return std::make_pair(d, first);
+}
+template <typename I>
+std::pair<typename std::iterator_traits<I>::value_type, I>
+lcm_range(I first, I last) BOOST_GCD_NOEXCEPT(I)
+{
+    BOOST_ASSERT(first != last);
+    typedef typename std::iterator_traits<I>::value_type T;
+
+    T d = *first;
+    ++first;
+    while (d != T(0) && first != last)
+    {
+        d = lcm(d, *first);
+        ++first;
+    }
+    return std::make_pair(d, first);
+}
+
+template < typename IntegerType >
+class gcd_evaluator
+#ifdef BOOST_NO_CXX11_HDR_FUNCTIONAL
+   : public std::binary_function<IntegerType, IntegerType, IntegerType>
+#endif
+{
+public:
+#ifndef BOOST_NO_CXX11_HDR_FUNCTIONAL
+   typedef IntegerType first_argument_type;
+   typedef IntegerType second_argument_type;
+   typedef IntegerType result_type;
+#endif
+   IntegerType operator()(IntegerType const &a, IntegerType const &b) const
+   {
+      return boost::integer::gcd(a, b);
+   }
+};
+
+template < typename IntegerType >
+class lcm_evaluator
+#ifdef BOOST_NO_CXX11_HDR_FUNCTIONAL
+   : public std::binary_function<IntegerType, IntegerType, IntegerType>
+#endif
+{
+public:
+#ifndef BOOST_NO_CXX11_HDR_FUNCTIONAL
+   typedef IntegerType first_argument_type;
+   typedef IntegerType second_argument_type;
+   typedef IntegerType result_type;
+#endif
+   IntegerType operator()(IntegerType const &a, IntegerType const &b)const
+   {
+      return boost::integer::lcm(a, b);
+   }
+};
+
+}  // namespace integer
+}  // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif  // BOOST_INTEGER_COMMON_FACTOR_RT_HPP

include/boost/integer/extended_euclidean.hpp

@@ -0,0 +1,83 @@
+/*
+ *  (C) Copyright Nick Thompson 2018.
+ *  Use, modification and distribution are subject to the
+ *  Boost Software License, Version 1.0. (See accompanying file
+ *  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef BOOST_INTEGER_EXTENDED_EUCLIDEAN_HPP
+#define BOOST_INTEGER_EXTENDED_EUCLIDEAN_HPP
+#include <limits>
+#include <stdexcept>
+#include <boost/throw_exception.hpp>
+#include <boost/core/invoke_swap.hpp>
+#include <boost/core/enable_if.hpp>
+
+namespace boost { namespace integer {
+
+// From "The Joy of Factoring", Algorithm 2.7, with a small optimization to remove tmps from Wikipedia.
+// Solves mx + ny = gcd(m,n). Returns tuple with (gcd(m,n), x, y).
+
+template<class Z>
+struct euclidean_result_t
+{
+    Z gcd;
+    Z x;
+    Z y;
+};
+
+template<class Z>
+typename boost::enable_if_c< std::numeric_limits< Z >::is_signed, euclidean_result_t< Z > >::type
+extended_euclidean(Z m, Z n)
+{
+    if (m < 1 || n < 1)
+    {
+        BOOST_THROW_EXCEPTION(std::domain_error("extended_euclidean: arguments must be strictly positive"));
+    }
+
+    bool swapped = false;
+    if (m < n)
+    {
+        swapped = true;
+        boost::core::invoke_swap(m, n);
+    }
+    Z u0 = m;
+    Z u1 = 1;
+    Z u2 = 0;
+    Z v0 = n;
+    Z v1 = 0;
+    Z v2 = 1;
+    Z w0;
+    Z w1;
+    Z w2;
+    while(v0 > 0)
+    {
+        Z q = u0/v0;
+        w0 = u0 - q*v0;
+        w1 = u1 - q*v1;
+        w2 = u2 - q*v2;
+        u0 = v0;
+        u1 = v1;
+        u2 = v2;
+        v0 = w0;
+        v1 = w1;
+        v2 = w2;
+    }
+
+    euclidean_result_t< Z > result;
+    result.gcd = u0;
+    if (!swapped)
+    {
+        result.x = u1;
+        result.y = u2;
+    }
+    else
+    {
+        result.x = u2;
+        result.y = u1;
+    }
+
+    return result;
+}
+
+}}
+#endif

include/boost/integer/integer_log2.hpp

@@ -0,0 +1,117 @@
+// -----------------------------------------------------------
+// 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
+//            Copyright (c) 2022 Andrey Semashev
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          https://www.boost.org/LICENSE_1_0.txt)
+//
+// -----------------------------------------------------------
+
+#ifndef BOOST_INTEGER_INTEGER_LOG2_HPP
+#define BOOST_INTEGER_INTEGER_LOG2_HPP
+
+#include <climits>
+#include <limits>
+#include <boost/config.hpp>
+#include <boost/assert.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/core/bit.hpp>
+#include <boost/core/enable_if.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+
+namespace boost {
+namespace detail {
+
+// helper to find the maximum power of two
+// less than p
+template< unsigned int p, unsigned int n, bool = ((2u * n) < p) >
+struct max_pow2_less :
+    public max_pow2_less< p, 2u * n >
+{
+};
+
+template< unsigned int p, unsigned int n >
+struct max_pow2_less< p, n, false >
+{
+    BOOST_STATIC_CONSTANT(unsigned int, value = n);
+};
+
+template< typename T >
+inline typename boost::disable_if< boost::is_integral< T >, int >::type integer_log2_impl(T x)
+{
+    unsigned int n = detail::max_pow2_less<
+        std::numeric_limits< T >::digits,
+        CHAR_BIT / 2u
+    >::value;
+
+    int result = 0;
+    while (x != 1)
+    {
+        T t(x >> n);
+        if (t)
+        {
+            result += static_cast< int >(n);
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+            x = static_cast< T&& >(t);
+#else
+            x = t;
+#endif
+        }
+        n >>= 1u;
+    }
+
+    return result;
+}
+
+template< typename T >
+inline typename boost::enable_if< boost::is_integral< T >, int >::type integer_log2_impl(T x)
+{
+    // We could simply rely on numeric_limits but sometimes
+    // Borland tries to use numeric_limits<const T>, because
+    // of its usual const-related problems in argument deduction
+    // - gps
+    return static_cast< int >((sizeof(T) * CHAR_BIT - 1u) -
+        boost::core::countl_zero(static_cast< typename boost::make_unsigned< T >::type >(x)));
+}
+
+#if defined(BOOST_HAS_INT128)
+// We need to provide explicit overloads for __int128 because (a) boost/core/bit.hpp currently does not support it and
+// (b) std::numeric_limits are not specialized for __int128 in some standard libraries.
+inline int integer_log2_impl(boost::uint128_type x)
+{
+    const boost::uint64_t x_hi = static_cast< boost::uint64_t >(x >> 64u);
+    if (x_hi != 0u)
+        return 127 - boost::core::countl_zero(x_hi);
+    else
+        return 63 - boost::core::countl_zero(static_cast< boost::uint64_t >(x));
+}
+
+inline int integer_log2_impl(boost::int128_type x)
+{
+    return detail::integer_log2_impl(static_cast< boost::uint128_type >(x));
+}
+#endif // defined(BOOST_HAS_INT128)
+
+} // namespace detail
+
+
+// ------------
+// integer_log2
+// ------------
+template< typename T >
+inline int integer_log2(T x)
+{
+    BOOST_ASSERT(x > 0);
+    return detail::integer_log2_impl(x);
+}
+
+} // namespace boost
+
+#endif // BOOST_INTEGER_INTEGER_LOG2_HPP

include/boost/integer/integer_mask.hpp

@@ -3,9 +3,9 @@
 //  (C) Copyright Daryle Walker 2001.
 //  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)
+//  https://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org for updates, documentation, and revision history. 
+//  See https://www.boost.org for updates, documentation, and revision history. 
 
 #ifndef BOOST_INTEGER_INTEGER_MASK_HPP
 #define BOOST_INTEGER_INTEGER_MASK_HPP
@@ -57,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 >  { \

include/boost/integer/mod_inverse.hpp

@@ -0,0 +1,53 @@
+/*
+ *  (C) Copyright Nick Thompson 2018.
+ *  Use, modification and distribution are subject to the
+ *  Boost Software License, Version 1.0. (See accompanying file
+ *  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
+ */
+#ifndef BOOST_INTEGER_MOD_INVERSE_HPP
+#define BOOST_INTEGER_MOD_INVERSE_HPP
+#include <stdexcept>
+#include <boost/throw_exception.hpp>
+#include <boost/integer/extended_euclidean.hpp>
+
+namespace boost { namespace integer {
+
+// From "The Joy of Factoring", Algorithm 2.7.
+// Here's some others names I've found for this function:
+// PowerMod[a, -1, m] (Mathematica)
+// mpz_invert (gmplib)
+// modinv (some dude on stackoverflow)
+// Would mod_inverse be sometimes mistaken as the modular *additive* inverse?
+// In any case, I think this is the best name we can get for this function without agonizing.
+template<class Z>
+Z mod_inverse(Z a, Z modulus)
+{
+    if (modulus < Z(2))
+    {
+        BOOST_THROW_EXCEPTION(std::domain_error("mod_inverse: modulus must be > 1"));
+    }
+    // make sure a < modulus:
+    a = a % modulus;
+    if (a == Z(0))
+    {
+        // a doesn't have a modular multiplicative inverse:
+        return Z(0);
+    }
+    boost::integer::euclidean_result_t<Z> u = boost::integer::extended_euclidean(a, modulus);
+    if (u.gcd > Z(1))
+    {
+        return Z(0);
+    }
+    // x might not be in the range 0 < x < m, let's fix that:
+    while (u.x <= Z(0))
+    {
+        u.x += modulus;
+    }
+    // While indeed this is an inexpensive and comforting check,
+    // the multiplication overflows and hence makes the check itself buggy.
+    //BOOST_ASSERT(u.x*a % modulus == 1);
+    return u.x;
+}
+
+}}
+#endif

include/boost/integer/static_log2.hpp

@@ -6,17 +6,18 @@
 //
 //     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)
+//              https://www.boost.org/LICENSE_1_0.txt)
 //
 //         ---------------------------------------------------
-//       See http://www.boost.org/libs/integer for documentation.
+//       See https://www.boost.org/libs/integer for documentation.
 // ------------------------------------------------------------------------- //
 
 
 #ifndef BOOST_INTEGER_STATIC_LOG2_HPP
 #define BOOST_INTEGER_STATIC_LOG2_HPP
 
-#include "boost/integer_fwd.hpp" // for boost::intmax_t
+#include <boost/config.hpp>
+#include <boost/integer_fwd.hpp>
 
 namespace boost {
 
@@ -122,6 +123,4 @@ namespace boost {
 
 }
 
-
-
 #endif // include guard

include/boost/integer/static_min_max.hpp

@@ -3,13 +3,14 @@
 //  (C) Copyright Daryle Walker 2001.
 //  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)
+//  https://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org for updates, documentation, and revision history. 
+//  See https://www.boost.org for updates, documentation, and revision history. 
 
 #ifndef BOOST_INTEGER_STATIC_MIN_MAX_HPP
 #define BOOST_INTEGER_STATIC_MIN_MAX_HPP
 
+#include <boost/config.hpp>
 #include <boost/integer_fwd.hpp>  // self include
 
 namespace boost

include/boost/integer_fwd.hpp

@@ -2,9 +2,9 @@
 
 //  (C) Copyright Dave Abrahams and Daryle Walker 2001. 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)
+//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org/libs/integer for documentation.
+//  See https://www.boost.org/libs/integer for documentation.
 
 #ifndef BOOST_INTEGER_FWD_HPP
 #define BOOST_INTEGER_FWD_HPP
@@ -158,6 +158,32 @@ 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
+     typedef unsigned long static_gcd_type;
+#else
+     typedef boost::uintmax_t static_gcd_type;
+#endif
+
+template < static_gcd_type Value1, static_gcd_type Value2 >
+    struct static_gcd;
+template < static_gcd_type Value1, static_gcd_type Value2 >
+    struct static_lcm;
+
+
+//  From <boost/integer/common_factor_rt.hpp>
+
+template < typename IntegerType >
+    class gcd_evaluator;
+template < typename IntegerType >
+    class lcm_evaluator;
+
+} // namespace integer
+
 }  // namespace boost
 
 

include/boost/integer_traits.hpp

@@ -3,14 +3,14 @@
  * Copyright Jens Maurer 2000
  * 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)
+ * https://www.boost.org/LICENSE_1_0.txt)
  *
  * $Id$
  *
  * Idea by Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers
  */
 
-//  See http://www.boost.org/libs/integer for documentation.
+//  See https://www.boost.org/libs/integer for documentation.
 
 
 #ifndef BOOST_INTEGER_TRAITS_HPP
@@ -103,7 +103,7 @@ class integer_traits<wchar_t>
     // library: they are wrong!
 #if defined(WCHAR_MIN) && defined(WCHAR_MAX) && !defined(__APPLE__)
     public detail::integer_traits_base<wchar_t, WCHAR_MIN, WCHAR_MAX>
-#elif defined(__BORLANDC__) || defined(__CYGWIN__) || defined(__MINGW32__) || (defined(__BEOS__) && defined(__GNUC__))
+#elif defined(BOOST_BORLANDC) || defined(__CYGWIN__) || defined(__MINGW32__) || (defined(__BEOS__) && defined(__GNUC__))
     // No WCHAR_MIN and WCHAR_MAX, whar_t is short and unsigned:
     public detail::integer_traits_base<wchar_t, 0, 0xffff>
 #elif (defined(__sgi) && (!defined(__SGI_STL_PORT) || __SGI_STL_PORT < 0x400))\
@@ -119,11 +119,6 @@ class integer_traits<wchar_t>
     //  - Mac OS X with native library
     //  - gcc on FreeBSD, OpenBSD and NetBSD
     public detail::integer_traits_base<wchar_t, INT_MIN, INT_MAX>
-#elif defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 2) && !defined(__SGI_STL_PORT)
-    // No WCHAR_MIN and WCHAR_MAX, wchar_t has the same range as unsigned int.
-    //  - gcc 2.95.x on HP-UX
-    // (also, std::numeric_limits<wchar_t> appears to return the wrong values).
-    public detail::integer_traits_base<wchar_t, 0, UINT_MAX>
 #else
 #error No WCHAR_MIN and WCHAR_MAX present, please adjust integer_traits<> for your compiler.
 #endif

include/boost/pending/integer_log2.hpp

@@ -0,0 +1,9 @@
+#ifndef BOOST_PENDING_INTEGER_LOG2_HPP
+#define BOOST_PENDING_INTEGER_LOG2_HPP
+
+#include <boost/integer/integer_log2.hpp>
+#include <boost/config/header_deprecated.hpp>
+
+BOOST_HEADER_DEPRECATED("<boost/integer/integer_log2.hpp>");
+
+#endif

index.html

@@ -7,7 +7,7 @@ Automatic redirection failed, please go to
 <a href="doc/html/index.html">doc/html/index.html</a>.
       <P>Copyright Beman Dawes, Daryle Walker, Gennaro Prota and John Maddock 2001-2009</P>
       <P>Distributed under the Boost Software License, Version 1.0. (See accompanying file <A href="../../LICENSE_1_0.txt">
-            LICENSE_1_0.txt</A> or copy at <A href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</A>).</P>
+            LICENSE_1_0.txt</A> or copy at <A href="https://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</A>).</P>
 </body>
 </html>
 

meta/libraries.json

@@ -0,0 +1,14 @@
+{
+    "key": "integer",
+    "name": "Integer",
+    "description": "The organization of boost integer headers and classes is designed to take advantage of <stdint.h> types from the 1999 C standard without resorting to undefined behavior in terms of the 1998 C++ standard. The header <boost/cstdint.hpp> makes the standard integer types safely available in namespace boost without placing any names in namespace std.",
+    "category": [
+        "Math"
+    ],
+    "authors": "",
+    "maintainers": [
+        "Daryle Walker <darylew -at- hotmail.com>",
+        "Andrey Semashev <andrey.semashev -at- gmail.com>"
+    ],
+    "cxxstd": "03"
+}

test/Jamfile.v2

@@ -1,25 +1,39 @@
 #~ Copyright Rene Rivera 2008
 #~ 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)
+#~ (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
 import testing ;
+import ../../config/checks/config : requires ;
 
 project : requirements <warnings>all <toolset>gcc:<cxxflags>-Wextra ;
 
+obj has_gmpxx : has_gmpxx.cpp ;
+explicit has_gmpxx ;
+
 test-suite integer
-    : 
+    :
-        [ run cstdint_test.cpp : : : <toolset>gcc:<cxxflags>-Wno-long-long <toolset>darwin:<cxxflags>-Wno-long-long ]
-        [ run cstdint_test2.cpp : : : <toolset>gcc:<cxxflags>-Wno-long-long <toolset>darwin:<cxxflags>-Wno-long-long ]
         [ 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 ]
+        [ run integer_log2_test.cpp ]
         [ run static_log2_test.cpp ]
         [ run static_min_max_test.cpp ]
-        [ compile cstdint_include_test.cpp ]
+        [ run extended_euclidean_test.cpp ]
+        [ run mod_inverse_test.cpp ]
         [ compile integer_traits_include_test.cpp ]
         [ compile integer_include_test.cpp ]
         [ compile integer_mask_include_test.cpp ]
         [ 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 ]
+        [ 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 ] ]
     ;

test/common_factor_test.cpp

@@ -0,0 +1,653 @@
+//  Boost GCD & LCM common_factor.hpp test program  --------------------------//
+
+//  (C) Copyright Daryle Walker 2001, 2006.
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  https://www.boost.org/LICENSE_1_0.txt)
+
+//  See https://www.boost.org for most recent version including documentation.
+
+//  Revision History
+//  01 Dec 2006  Various fixes for old compilers (Joaquin M Lopez Munoz)
+//  10 Nov 2006  Make long long and __int64 mutually exclusive (Daryle Walker)
+//  04 Nov 2006  Use more built-in numeric types, binary-GCD (Daryle Walker)
+//  03 Nov 2006  Use custom numeric types (Daryle Walker)
+//  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.integer GCD & LCM unit tests"
+
+#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/mersenne_twister.hpp>
+#include <boost/random/uniform_int.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
+
+#include "multiprecision_config.hpp"
+
+#ifndef DISABLE_MP_TESTS
+#include <boost/multiprecision/cpp_int.hpp>
+#endif
+
+namespace {
+
+// TODO: add polynominal/non-real type; especially after any switch to the
+// binary-GCD algorithm for built-in types
+
+// Custom integer class (template)
+template < typename IntType, int ID = 0 >
+class my_wrapped_integer
+    : private ::boost::shiftable1<my_wrapped_integer<IntType, ID>,
+        ::boost::operators<my_wrapped_integer<IntType, ID> > >
+{
+    // Helper type-aliases
+    typedef my_wrapped_integer    self_type;
+    typedef IntType self_type::*  bool_type;
+
+    // Member data
+    IntType  v_;
+
+public:
+    // Template parameters
+    typedef IntType  int_type;
+
+    BOOST_STATIC_CONSTANT(int,id = ID);
+
+    // Lifetime management (use automatic destructor and copy constructor)
+    my_wrapped_integer( int_type const &v = int_type() )  : v_( v )  {}
+
+    // Accessors
+    int_type  value() const  { return this->v_; }
+
+    // Operators (use automatic copy assignment)
+    operator bool_type() const  { return this->v_ ? &self_type::v_ : 0; }
+
+    self_type &  operator ++()  { ++this->v_; return *this; }
+    self_type &  operator --()  { --this->v_; return *this; }
+
+    self_type  operator ~() const  { return self_type( ~this->v_ ); }
+    self_type  operator !() const  { return self_type( !this->v_ ); }
+    self_type  operator +() const  { return self_type( +this->v_ ); }
+    self_type  operator -() const  { return self_type( -this->v_ ); }
+
+    bool  operator  <( self_type const &r ) const  { return this->v_ < r.v_; }
+    bool  operator ==( self_type const &r ) const  { return this->v_ == r.v_; }
+
+    self_type &operator *=(self_type const &r) {this->v_ *= r.v_; return *this;}
+    self_type &operator /=(self_type const &r) {this->v_ /= r.v_; return *this;}
+    self_type &operator %=(self_type const &r) {this->v_ %= r.v_; return *this;}
+    self_type &operator +=(self_type const &r) {this->v_ += r.v_; return *this;}
+    self_type &operator -=(self_type const &r) {this->v_ -= r.v_; return *this;}
+    self_type &operator<<=(self_type const &r){this->v_ <<= r.v_; return *this;}
+    self_type &operator>>=(self_type const &r){this->v_ >>= r.v_; return *this;}
+    self_type &operator &=(self_type const &r) {this->v_ &= r.v_; return *this;}
+    self_type &operator |=(self_type const &r) {this->v_ |= r.v_; return *this;}
+    self_type &operator ^=(self_type const &r) {this->v_ ^= r.v_; return *this;}
+
+    // Input & output
+    friend std::istream & operator >>( std::istream &i, self_type &x )
+    { return i >> x.v_; }
+
+    friend std::ostream & operator <<( std::ostream &o, self_type const &x )
+    { return o << x.v_; }
+
+};  // my_wrapped_integer
+
+template < typename IntType, int ID >
+my_wrapped_integer<IntType, ID>  abs( my_wrapped_integer<IntType, ID> const &x )
+{ return ( x < my_wrapped_integer<IntType, ID>(0) ) ? -x : +x; }
+
+typedef my_wrapped_integer<int>          MyInt1;
+typedef my_wrapped_integer<unsigned>     MyUnsigned1;
+typedef my_wrapped_integer<int, 1>       MyInt2;
+typedef my_wrapped_integer<unsigned, 1>  MyUnsigned2;
+
+// Without these explicit instantiations, MSVC++ 6.5/7.0 does not find
+// some friend operators in certain contexts.
+MyInt1       dummy1;
+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 /**/
+
+// Specialize numeric_limits for _some_ of our types
+namespace std
+{
+
+template < >
+class numeric_limits< MyInt1 >
+{
+    typedef MyInt1::int_type             int_type;
+    typedef numeric_limits<int_type>  limits_type;
+
+public:
+    BOOST_STATIC_CONSTANT(bool, is_specialized = limits_type::is_specialized);
+
+    static MyInt1 min BOOST_NO_MACRO_EXPAND() throw()  { return (limits_type::min)(); }
+    static MyInt1 max BOOST_NO_MACRO_EXPAND() throw()  { return (limits_type::max)(); }
+
+    BOOST_STATIC_CONSTANT(int, digits      = limits_type::digits);
+    BOOST_STATIC_CONSTANT(int, digits10    = limits_type::digits10);
+#ifndef BOOST_NO_CXX11_NUMERIC_LIMITS
+    BOOST_STATIC_CONSTANT(int, max_digits10    = limits_type::max_digits10);
+#endif
+    BOOST_STATIC_CONSTANT(bool, is_signed  = limits_type::is_signed);
+    BOOST_STATIC_CONSTANT(bool, is_integer = limits_type::is_integer);
+    BOOST_STATIC_CONSTANT(bool, is_exact   = limits_type::is_exact);
+    BOOST_STATIC_CONSTANT(int, radix       = limits_type::radix);
+    static MyInt1 epsilon() throw()      { return limits_type::epsilon(); }
+    static MyInt1 round_error() throw()  { return limits_type::round_error(); }
+
+    BOOST_STATIC_CONSTANT(int, min_exponent   = limits_type::min_exponent);
+    BOOST_STATIC_CONSTANT(int, min_exponent10 = limits_type::min_exponent10);
+    BOOST_STATIC_CONSTANT(int, max_exponent   = limits_type::max_exponent);
+    BOOST_STATIC_CONSTANT(int, max_exponent10 = limits_type::max_exponent10);
+
+    BOOST_STATIC_CONSTANT(bool, has_infinity             = limits_type::has_infinity);
+    BOOST_STATIC_CONSTANT(bool, has_quiet_NaN            = limits_type::has_quiet_NaN);
+    BOOST_STATIC_CONSTANT(bool, has_signaling_NaN        = limits_type::has_signaling_NaN);
+    BOOST_STATIC_CONSTANT(float_denorm_style, has_denorm = limits_type::has_denorm);
+    BOOST_STATIC_CONSTANT(bool, has_denorm_loss          = limits_type::has_denorm_loss);
+
+    static MyInt1 infinity() throw()      { return limits_type::infinity(); }
+    static MyInt1 quiet_NaN() throw()     { return limits_type::quiet_NaN(); }
+    static MyInt1 signaling_NaN() throw() {return limits_type::signaling_NaN();}
+    static MyInt1 denorm_min() throw()    { return limits_type::denorm_min(); }
+
+    BOOST_STATIC_CONSTANT(bool, is_iec559  = limits_type::is_iec559);
+    BOOST_STATIC_CONSTANT(bool, is_bounded = limits_type::is_bounded);
+    BOOST_STATIC_CONSTANT(bool, is_modulo  = limits_type::is_modulo);
+
+    BOOST_STATIC_CONSTANT(bool, traps                    = limits_type::traps);
+    BOOST_STATIC_CONSTANT(bool, tinyness_before          = limits_type::tinyness_before);
+    BOOST_STATIC_CONSTANT(float_round_style, round_style = limits_type::round_style);
+
+};  // std::numeric_limits<MyInt1>
+
+template < >
+class numeric_limits< MyUnsigned1 >
+{
+    typedef MyUnsigned1::int_type        int_type;
+    typedef numeric_limits<int_type>  limits_type;
+
+public:
+    BOOST_STATIC_CONSTANT(bool, is_specialized = limits_type::is_specialized);
+
+    static MyUnsigned1 min BOOST_NO_MACRO_EXPAND() throw()  { return (limits_type::min)(); }
+    static MyUnsigned1 max BOOST_NO_MACRO_EXPAND() throw()  { return (limits_type::max)(); }
+
+    BOOST_STATIC_CONSTANT(int, digits      = limits_type::digits);
+    BOOST_STATIC_CONSTANT(int, digits10    = limits_type::digits10);
+#ifndef BOOST_NO_CXX11_NUMERIC_LIMITS
+    BOOST_STATIC_CONSTANT(int, max_digits10    = limits_type::max_digits10);
+#endif
+    BOOST_STATIC_CONSTANT(bool, is_signed  = limits_type::is_signed);
+    BOOST_STATIC_CONSTANT(bool, is_integer = limits_type::is_integer);
+    BOOST_STATIC_CONSTANT(bool, is_exact   = limits_type::is_exact);
+    BOOST_STATIC_CONSTANT(int, radix       = limits_type::radix);
+    static MyUnsigned1 epsilon() throw()      { return limits_type::epsilon(); }
+    static MyUnsigned1 round_error() throw(){return limits_type::round_error();}
+
+    BOOST_STATIC_CONSTANT(int, min_exponent   = limits_type::min_exponent);
+    BOOST_STATIC_CONSTANT(int, min_exponent10 = limits_type::min_exponent10);
+    BOOST_STATIC_CONSTANT(int, max_exponent   = limits_type::max_exponent);
+    BOOST_STATIC_CONSTANT(int, max_exponent10 = limits_type::max_exponent10);
+
+    BOOST_STATIC_CONSTANT(bool, has_infinity             = limits_type::has_infinity);
+    BOOST_STATIC_CONSTANT(bool, has_quiet_NaN            = limits_type::has_quiet_NaN);
+    BOOST_STATIC_CONSTANT(bool, has_signaling_NaN        = limits_type::has_signaling_NaN);
+    BOOST_STATIC_CONSTANT(float_denorm_style, has_denorm = limits_type::has_denorm);
+    BOOST_STATIC_CONSTANT(bool, has_denorm_loss          = limits_type::has_denorm_loss);
+
+    static MyUnsigned1 infinity() throw()    { return limits_type::infinity(); }
+    static MyUnsigned1 quiet_NaN() throw()  { return limits_type::quiet_NaN(); }
+    static MyUnsigned1 signaling_NaN() throw()
+        { return limits_type::signaling_NaN(); }
+    static MyUnsigned1 denorm_min() throw(){ return limits_type::denorm_min(); }
+
+    BOOST_STATIC_CONSTANT(bool, is_iec559  = limits_type::is_iec559);
+    BOOST_STATIC_CONSTANT(bool, is_bounded = limits_type::is_bounded);
+    BOOST_STATIC_CONSTANT(bool, is_modulo  = limits_type::is_modulo);
+
+    BOOST_STATIC_CONSTANT(bool, traps                    = limits_type::traps);
+    BOOST_STATIC_CONSTANT(bool, tinyness_before          = limits_type::tinyness_before);
+    BOOST_STATIC_CONSTANT(float_round_style, round_style = limits_type::round_style);
+
+};  // std::numeric_limits<MyUnsigned1>
+
+#if BOOST_WORKAROUND(BOOST_MSVC,<1300)
+// MSVC 6.0 lacks operator<< for __int64, see
+// https://support.microsoft.com/kb/168440/
+
+inline ostream& operator<<(ostream& os, __int64 i)
+{
+    char buf[20];
+    sprintf(buf,"%I64d", i);
+    os << buf;
+    return os;
+}
+
+inline ostream& operator<<(ostream& os, unsigned __int64 i)
+{
+    char buf[20];
+    sprintf(buf,"%I64u", i);
+    os << buf;
+    return os;
+}
+#endif
+
+}  // namespace std
+
+// GCD tests
+
+// 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( 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(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( 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
+
+    // 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 );
+}
+
+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( 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(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( 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
+
+    // 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 );
+}
+
+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);
+
+   unsigned i_gcd_unity[] = { 44, 56, 1, 88 };
+   BOOST_TEST_EQ(boost::integer::gcd_range(i_gcd_unity, i_gcd_unity + 4).first, 1);
+   BOOST_TEST_EQ(boost::integer::gcd_range(i_gcd_unity, i_gcd_unity + 4).second, i_gcd_unity + 3);
+
+   unsigned i_lcm_unity[] = { 44, 56, 0, 88 };
+   BOOST_TEST_EQ(boost::integer::lcm_range(i_lcm_unity, i_lcm_unity + 4).first, 0);
+   BOOST_TEST_EQ(boost::integer::lcm_range(i_lcm_unity, i_lcm_unity + 4).second, i_lcm_unity + 3);
+
+#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
+}
+
+// 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 ) \
+    TEST_SIGNED_( test ) \
+    test<boost::long_long_type>();
+#elif defined(BOOST_HAS_MS_INT64)
+# 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>(); \
+    test<unsigned>(); \
+    test<unsigned long>(); \
+    test<MyUnsigned1>(); \
+    test<MyUnsigned2>();
+#endif
+
+#ifdef BOOST_HAS_LONG_LONG
+# define TEST_UNSIGNED( test ) \
+    TEST_UNSIGNED_( test ) \
+    test<boost::ulong_long_type>();
+#elif defined(BOOST_HAS_MS_INT64)
+# define TEST_UNSIGNED( test ) \
+    TEST_UNSIGNED_( 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();
+   gcd_method_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();
+}

test/cstdint_include_test.cpp

@@ -1,69 +0,0 @@
-//  Copyright John Maddock 2009.  
-//  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)
-
-#define __STDC_CONSTANT_MACROS
-#include <boost/cstdint.hpp> // must be the only #include!
-
-int main()
-{
-   boost::int8_t i8 = INT8_C(0);
-   (void)i8;
-   boost::uint8_t ui8 = UINT8_C(0);
-   (void)ui8;
-   boost::int16_t i16 = INT16_C(0);
-   (void)i16;
-   boost::uint16_t ui16 = UINT16_C(0);
-   (void)ui16;
-   boost::int32_t i32 = INT32_C(0);
-   (void)i32;
-   boost::uint32_t ui32 = UINT32_C(0);
-   (void)ui32;
-#ifndef BOOST_NO_INT64_T
-   boost::int64_t i64 = 0;
-   (void)i64;
-   boost::uint64_t ui64 = 0;
-   (void)ui64;
-#endif
-   boost::int_least8_t i8least = INT8_C(0);
-   (void)i8least;
-   boost::uint_least8_t ui8least = UINT8_C(0);
-   (void)ui8least;
-   boost::int_least16_t i16least = INT16_C(0);
-   (void)i16least;
-   boost::uint_least16_t ui16least = UINT16_C(0);
-   (void)ui16least;
-   boost::int_least32_t i32least = INT32_C(0);
-   (void)i32least;
-   boost::uint_least32_t ui32least = UINT32_C(0);
-   (void)ui32least;
-#ifndef BOOST_NO_INT64_T
-   boost::int_least64_t i64least = 0;
-   (void)i64least;
-   boost::uint_least64_t ui64least = 0;
-   (void)ui64least;
-#endif
-   boost::int_fast8_t i8fast = INT8_C(0);
-   (void)i8fast;
-   boost::uint_fast8_t ui8fast = UINT8_C(0);
-   (void)ui8fast;
-   boost::int_fast16_t i16fast = INT16_C(0);
-   (void)i16fast;
-   boost::uint_fast16_t ui16fast = UINT16_C(0);
-   (void)ui16fast;
-   boost::int_fast32_t i32fast = INT32_C(0);
-   (void)i32fast;
-   boost::uint_fast32_t ui32fast = UINT32_C(0);
-   (void)ui32fast;
-#ifndef BOOST_NO_INT64_T
-   boost::int_fast64_t i64fast = 0;
-   (void)i64fast;
-   boost::uint_fast64_t ui64fast = 0;
-   (void)ui64fast;
-#endif
-   boost::intmax_t im = 0;
-   (void)im;
-   boost::uintmax_t uim = 0;
-   (void)uim;
-}

test/cstdint_test.cpp

@@ -1,238 +0,0 @@
-//  boost cstdint.hpp test program  ------------------------------------------//
-
-//  Copyright Beman Dawes 2000.  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)
-
-
-//  See http://www.boost.org/libs/integer for documentation.
-
-//  Revision History
-//   11 Sep 01  Adapted to work with macros defined in native stdint.h (John Maddock)
-//   12 Nov 00  Adapted to merged <boost/cstdint.hpp>
-//   23 Sep 00  Added INTXX_C constant macro support + int64_t support (John Maddock).
-//   28 Jun 00  Initial version
-
-//
-// There are two ways to test this: in version 1, we include cstdint.hpp as the first
-// include, which means we get decide whether __STDC_CONSTANT_MACROS is defined.
-// In version two we include stdint.h with __STDC_CONSTANT_MACROS *NOT* defined first,
-// and check that we still end up with compatible definitions for the INT#_C macros.
-//
-// This is version 1.
-//
-
-#if defined(__GNUC__) && (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4))
-// We can't suppress this warning on the command line as not all GCC versions support -Wno-type-limits :
-#pragma GCC diagnostic ignored "-Wtype-limits"
-#endif
-
-#include <boost/cstdint.hpp>
-#include <boost/detail/lightweight_test.hpp>
-#include <iostream>
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-//
-// the following class is designed to verify
-// that the various INTXX_C macros can be used
-// in integral constant expressions:
-//
-struct integral_constant_checker
-{
-  static const boost::int8_t          int8          = INT8_C(-127);
-  static const boost::int_least8_t    int_least8    = INT8_C(-127);
-  static const boost::int_fast8_t     int_fast8     = INT8_C(-127);
-
-  static const boost::uint8_t         uint8         = UINT8_C(255);
-  static const boost::uint_least8_t   uint_least8   = UINT8_C(255);
-  static const boost::uint_fast8_t    uint_fast8    = UINT8_C(255);
-
-  static const boost::int16_t         int16         = INT16_C(-32767);
-  static const boost::int_least16_t   int_least16   = INT16_C(-32767);
-  static const boost::int_fast16_t    int_fast16    = INT16_C(-32767);
-
-  static const boost::uint16_t        uint16         = UINT16_C(65535);
-  static const boost::uint_least16_t  uint_least16   = UINT16_C(65535);
-  static const boost::uint_fast16_t   uint_fast16    = UINT16_C(65535);
-
-  static const boost::int32_t         int32         = INT32_C(-2147483647);
-  static const boost::int_least32_t   int_least32   = INT32_C(-2147483647);
-  static const boost::int_fast32_t    int_fast32    = INT32_C(-2147483647);
-
-  static const boost::uint32_t        uint32        = UINT32_C(4294967295);
-  static const boost::uint_least32_t  uint_least32  = UINT32_C(4294967295);
-  static const boost::uint_fast32_t   uint_fast32   = UINT32_C(4294967295);
-
-  static void check();
-};
-
-void integral_constant_checker::check()
-{
-  BOOST_TEST( int8 == -127 );
-  BOOST_TEST( int_least8 == -127 );
-  BOOST_TEST( int_fast8 == -127 );
-  BOOST_TEST( uint8 == 255u );
-  BOOST_TEST( uint_least8 == 255u );
-  BOOST_TEST( uint_fast8 == 255u );
-  BOOST_TEST( int16 == -32767 );
-  BOOST_TEST( int_least16 == -32767 );
-  BOOST_TEST( int_fast16 == -32767 );
-  BOOST_TEST( uint16 == 65535u );
-  BOOST_TEST( uint_least16 == 65535u );
-  BOOST_TEST( uint_fast16 == 65535u );
-  BOOST_TEST( int32 == -2147483647 );
-  BOOST_TEST( int_least32 == -2147483647 );
-  BOOST_TEST( int_fast32 == -2147483647 );
-  BOOST_TEST( uint32 == 4294967295u );
-  BOOST_TEST( uint_least32 == 4294967295u );
-  BOOST_TEST( uint_fast32 == 4294967295u );
-}
-#endif // BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-
-//
-// the following function simply verifies that the type
-// of an integral constant is correctly defined:
-//
-#ifdef __BORLANDC__
-#pragma option -w-8008
-#pragma option -w-8066
-#endif
-template <class T1, class T2>
-void integral_constant_type_check(T1, T2)
-{
-   //
-   // the types T1 and T2 may not be exactly
-   // the same type, but they should be the
-   // same size and signedness. We could use
-   // numeric_limits to verify this, but
-   // numeric_limits implementations currently
-   // vary too much, or are incomplete or missing.
-   //
-   T1 t1 = static_cast<T1>(-1);  // cast suppresses warnings
-   T2 t2 = static_cast<T2>(-1);  // ditto
-#if defined(BOOST_HAS_STDINT_H)
-   // if we have a native stdint.h
-   // then the INTXX_C macros may define
-   // a type that's wider than required:
-   BOOST_TEST(sizeof(T1) <= sizeof(T2));
-#else
-   BOOST_TEST(sizeof(T1) == sizeof(T2));
-   BOOST_TEST(t1 == t2);
-#endif
-#if defined(BOOST_HAS_STDINT_H)
-   // native headers are permitted to promote small
-   // unsigned types to type int:
-   if(sizeof(T1) >= sizeof(int))
-   {
-      if(t1 > 0)
-        BOOST_TEST(t2 > 0);
-      else
-        BOOST_TEST(!(t2 > 0));
-   }
-   else if(t1 < 0)
-      BOOST_TEST(!(t2 > 0));
-#else
-   if(t1 > 0)
-     BOOST_TEST(t2 > 0);
-   else
-     BOOST_TEST(!(t2 > 0));
-#endif
-}
-
-
-int main(int, char*[])
-{
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-  integral_constant_checker::check();
-#endif
-  //
-  // verify the types of the integral constants:
-  //
-  integral_constant_type_check(boost::int8_t(0), INT8_C(0));
-  integral_constant_type_check(boost::uint8_t(0), UINT8_C(0));
-  integral_constant_type_check(boost::int16_t(0), INT16_C(0));
-  integral_constant_type_check(boost::uint16_t(0), UINT16_C(0));
-  integral_constant_type_check(boost::int32_t(0), INT32_C(0));
-  integral_constant_type_check(boost::uint32_t(0), UINT32_C(0));
-#ifndef BOOST_NO_INT64_T
-  integral_constant_type_check(boost::int64_t(0), INT64_C(0));
-  integral_constant_type_check(boost::uint64_t(0), UINT64_C(0));
-#endif
-  //
-  boost::int8_t          int8          = INT8_C(-127);
-  boost::int_least8_t    int_least8    = INT8_C(-127);
-  boost::int_fast8_t     int_fast8     = INT8_C(-127);
-
-  boost::uint8_t         uint8         = UINT8_C(255);
-  boost::uint_least8_t   uint_least8   = UINT8_C(255);
-  boost::uint_fast8_t    uint_fast8    = UINT8_C(255);
-
-  boost::int16_t         int16         = INT16_C(-32767);
-  boost::int_least16_t   int_least16   = INT16_C(-32767);
-  boost::int_fast16_t    int_fast16    = INT16_C(-32767);
-
-  boost::uint16_t        uint16         = UINT16_C(65535);
-  boost::uint_least16_t  uint_least16   = UINT16_C(65535);
-  boost::uint_fast16_t   uint_fast16    = UINT16_C(65535);
-
-  boost::int32_t         int32         = INT32_C(-2147483647);
-  boost::int_least32_t   int_least32   = INT32_C(-2147483647);
-  boost::int_fast32_t    int_fast32    = INT32_C(-2147483647);
-
-  boost::uint32_t        uint32        = UINT32_C(4294967295);
-  boost::uint_least32_t  uint_least32  = UINT32_C(4294967295);
-  boost::uint_fast32_t   uint_fast32   = UINT32_C(4294967295);
-
-#ifndef BOOST_NO_INT64_T
-  boost::int64_t         int64         = INT64_C(-9223372036854775807);
-  boost::int_least64_t   int_least64   = INT64_C(-9223372036854775807);
-  boost::int_fast64_t    int_fast64    = INT64_C(-9223372036854775807);
-
-  boost::uint64_t        uint64        = UINT64_C(18446744073709551615);
-  boost::uint_least64_t  uint_least64  = UINT64_C(18446744073709551615);
-  boost::uint_fast64_t   uint_fast64   = UINT64_C(18446744073709551615);
-
-  boost::intmax_t        intmax        = INTMAX_C(-9223372036854775807);
-  boost::uintmax_t       uintmax       = UINTMAX_C(18446744073709551615);
-#else
-  boost::intmax_t        intmax        = INTMAX_C(-2147483647);
-  boost::uintmax_t       uintmax       = UINTMAX_C(4294967295);
-#endif
-
-  BOOST_TEST( int8 == -127 );
-  BOOST_TEST( int_least8 == -127 );
-  BOOST_TEST( int_fast8 == -127 );
-  BOOST_TEST( uint8 == 255u );
-  BOOST_TEST( uint_least8 == 255u );
-  BOOST_TEST( uint_fast8 == 255u );
-  BOOST_TEST( int16 == -32767 );
-  BOOST_TEST( int_least16 == -32767 );
-  BOOST_TEST( int_fast16 == -32767 );
-  BOOST_TEST( uint16 == 65535u );
-  BOOST_TEST( uint_least16 == 65535u );
-  BOOST_TEST( uint_fast16 == 65535u );
-  BOOST_TEST( int32 == -2147483647 );
-  BOOST_TEST( int_least32 == -2147483647 );
-  BOOST_TEST( int_fast32 == -2147483647 );
-  BOOST_TEST( uint32 == 4294967295u );
-  BOOST_TEST( uint_least32 == 4294967295u );
-  BOOST_TEST( uint_fast32 == 4294967295u );
-
-#ifndef BOOST_NO_INT64_T
-  BOOST_TEST( int64 == INT64_C(-9223372036854775807) );
-  BOOST_TEST( int_least64 == INT64_C(-9223372036854775807) );
-  BOOST_TEST( int_fast64 == INT64_C(-9223372036854775807) );
-  BOOST_TEST( uint64 == UINT64_C(18446744073709551615) );
-  BOOST_TEST( uint_least64 == UINT64_C(18446744073709551615) );
-  BOOST_TEST( uint_fast64 == UINT64_C(18446744073709551615) );
-  BOOST_TEST( intmax == INT64_C(-9223372036854775807) );
-  BOOST_TEST( uintmax == UINT64_C(18446744073709551615) );
-#else
-  BOOST_TEST( intmax == -2147483647 );
-  BOOST_TEST( uintmax == 4294967295u );
-#endif
-
-
-  std::cout << "OK\n";
-  return boost::report_errors();
-}

test/cstdint_test2.cpp

@@ -1,248 +0,0 @@
-//  boost cstdint.hpp test program  ------------------------------------------//
-
-//  Copyright Beman Dawes 2000.  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)
-
-
-//  See http://www.boost.org/libs/integer for documentation.
-
-//  Revision History
-//   11 Sep 01  Adapted to work with macros defined in native stdint.h (John Maddock)
-//   12 Nov 00  Adapted to merged <boost/cstdint.hpp>
-//   23 Sep 00  Added INTXX_C constant macro support + int64_t support (John Maddock).
-//   28 Jun 00  Initial version
-
-//
-// There are two ways to test this: in version 1, we include cstdint.hpp as the first
-// include, which means we get decide whether __STDC_CONSTANT_MACROS is defined.
-// In version two we include stdint.h with __STDC_CONSTANT_MACROS *NOT* defined first,
-// and check that we still end up with compatible definitions for the INT#_C macros.
-//
-// This is version 2.
-//
-
-#if defined(__GNUC__) && (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4))
-// We can't suppress this warning on the command line as not all GCC versions support -Wno-type-limits :
-#pragma GCC diagnostic ignored "-Wtype-limits"
-#endif
-
-#include <boost/config.hpp>
-
-#ifdef BOOST_HAS_STDINT_H
-#ifdef __hpux
-#  include <inttypes.h>
-#else
-#  include <stdint.h>
-#endif
-#endif
-
-#include <boost/cstdint.hpp>
-#include <boost/detail/lightweight_test.hpp>
-#include <iostream>
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-//
-// the following class is designed to verify
-// that the various INTXX_C macros can be used
-// in integral constant expressions:
-//
-struct integral_constant_checker
-{
-  static const boost::int8_t          int8          = INT8_C(-127);
-  static const boost::int_least8_t    int_least8    = INT8_C(-127);
-  static const boost::int_fast8_t     int_fast8     = INT8_C(-127);
-
-  static const boost::uint8_t         uint8         = UINT8_C(255);
-  static const boost::uint_least8_t   uint_least8   = UINT8_C(255);
-  static const boost::uint_fast8_t    uint_fast8    = UINT8_C(255);
-
-  static const boost::int16_t         int16         = INT16_C(-32767);
-  static const boost::int_least16_t   int_least16   = INT16_C(-32767);
-  static const boost::int_fast16_t    int_fast16    = INT16_C(-32767);
-
-  static const boost::uint16_t        uint16         = UINT16_C(65535);
-  static const boost::uint_least16_t  uint_least16   = UINT16_C(65535);
-  static const boost::uint_fast16_t   uint_fast16    = UINT16_C(65535);
-
-  static const boost::int32_t         int32         = INT32_C(-2147483647);
-  static const boost::int_least32_t   int_least32   = INT32_C(-2147483647);
-  static const boost::int_fast32_t    int_fast32    = INT32_C(-2147483647);
-
-  static const boost::uint32_t        uint32        = UINT32_C(4294967295);
-  static const boost::uint_least32_t  uint_least32  = UINT32_C(4294967295);
-  static const boost::uint_fast32_t   uint_fast32   = UINT32_C(4294967295);
-
-  static void check();
-};
-
-void integral_constant_checker::check()
-{
-  BOOST_TEST( int8 == -127 );
-  BOOST_TEST( int_least8 == -127 );
-  BOOST_TEST( int_fast8 == -127 );
-  BOOST_TEST( uint8 == 255u );
-  BOOST_TEST( uint_least8 == 255u );
-  BOOST_TEST( uint_fast8 == 255u );
-  BOOST_TEST( int16 == -32767 );
-  BOOST_TEST( int_least16 == -32767 );
-  BOOST_TEST( int_fast16 == -32767 );
-  BOOST_TEST( uint16 == 65535u );
-  BOOST_TEST( uint_least16 == 65535u );
-  BOOST_TEST( uint_fast16 == 65535u );
-  BOOST_TEST( int32 == -2147483647 );
-  BOOST_TEST( int_least32 == -2147483647 );
-  BOOST_TEST( int_fast32 == -2147483647 );
-  BOOST_TEST( uint32 == 4294967295u );
-  BOOST_TEST( uint_least32 == 4294967295u );
-  BOOST_TEST( uint_fast32 == 4294967295u );
-}
-#endif // BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-
-//
-// the following function simply verifies that the type
-// of an integral constant is correctly defined:
-//
-#ifdef __BORLANDC__
-#pragma option -w-8008
-#pragma option -w-8066
-#endif
-template <class T1, class T2>
-void integral_constant_type_check(T1, T2)
-{
-   //
-   // the types T1 and T2 may not be exactly
-   // the same type, but they should be the
-   // same size and signedness. We could use
-   // numeric_limits to verify this, but
-   // numeric_limits implementations currently
-   // vary too much, or are incomplete or missing.
-   //
-   T1 t1 = static_cast<T1>(-1);  // cast suppresses warnings
-   T2 t2 = static_cast<T2>(-1);  // ditto
-#if defined(BOOST_HAS_STDINT_H)
-   // if we have a native stdint.h
-   // then the INTXX_C macros may define
-   // a type that's wider than required:
-   BOOST_TEST(sizeof(T1) <= sizeof(T2));
-#else
-   BOOST_TEST(sizeof(T1) == sizeof(T2));
-   BOOST_TEST(t1 == t2);
-#endif
-#if defined(BOOST_HAS_STDINT_H)
-   // native headers are permitted to promote small
-   // unsigned types to type int:
-   if(sizeof(T1) >= sizeof(int))
-   {
-      if(t1 > 0)
-        BOOST_TEST(t2 > 0);
-      else
-        BOOST_TEST(!(t2 > 0));
-   }
-   else if(t1 < 0)
-      BOOST_TEST(!(t2 > 0));
-#else
-   if(t1 > 0)
-     BOOST_TEST(t2 > 0);
-   else
-     BOOST_TEST(!(t2 > 0));
-#endif
-}
-
-
-int main(int, char*[])
-{
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-  integral_constant_checker::check();
-#endif
-  //
-  // verify the types of the integral constants:
-  //
-  integral_constant_type_check(boost::int8_t(0), INT8_C(0));
-  integral_constant_type_check(boost::uint8_t(0), UINT8_C(0));
-  integral_constant_type_check(boost::int16_t(0), INT16_C(0));
-  integral_constant_type_check(boost::uint16_t(0), UINT16_C(0));
-  integral_constant_type_check(boost::int32_t(0), INT32_C(0));
-  integral_constant_type_check(boost::uint32_t(0), UINT32_C(0));
-#ifndef BOOST_NO_INT64_T
-  integral_constant_type_check(boost::int64_t(0), INT64_C(0));
-  integral_constant_type_check(boost::uint64_t(0), UINT64_C(0));
-#endif
-  //
-  boost::int8_t          int8          = INT8_C(-127);
-  boost::int_least8_t    int_least8    = INT8_C(-127);
-  boost::int_fast8_t     int_fast8     = INT8_C(-127);
-
-  boost::uint8_t         uint8         = UINT8_C(255);
-  boost::uint_least8_t   uint_least8   = UINT8_C(255);
-  boost::uint_fast8_t    uint_fast8    = UINT8_C(255);
-
-  boost::int16_t         int16         = INT16_C(-32767);
-  boost::int_least16_t   int_least16   = INT16_C(-32767);
-  boost::int_fast16_t    int_fast16    = INT16_C(-32767);
-
-  boost::uint16_t        uint16         = UINT16_C(65535);
-  boost::uint_least16_t  uint_least16   = UINT16_C(65535);
-  boost::uint_fast16_t   uint_fast16    = UINT16_C(65535);
-
-  boost::int32_t         int32         = INT32_C(-2147483647);
-  boost::int_least32_t   int_least32   = INT32_C(-2147483647);
-  boost::int_fast32_t    int_fast32    = INT32_C(-2147483647);
-
-  boost::uint32_t        uint32        = UINT32_C(4294967295);
-  boost::uint_least32_t  uint_least32  = UINT32_C(4294967295);
-  boost::uint_fast32_t   uint_fast32   = UINT32_C(4294967295);
-
-#ifndef BOOST_NO_INT64_T
-  boost::int64_t         int64         = INT64_C(-9223372036854775807);
-  boost::int_least64_t   int_least64   = INT64_C(-9223372036854775807);
-  boost::int_fast64_t    int_fast64    = INT64_C(-9223372036854775807);
-
-  boost::uint64_t        uint64        = UINT64_C(18446744073709551615);
-  boost::uint_least64_t  uint_least64  = UINT64_C(18446744073709551615);
-  boost::uint_fast64_t   uint_fast64   = UINT64_C(18446744073709551615);
-
-  boost::intmax_t        intmax        = INTMAX_C(-9223372036854775807);
-  boost::uintmax_t       uintmax       = UINTMAX_C(18446744073709551615);
-#else
-  boost::intmax_t        intmax        = INTMAX_C(-2147483647);
-  boost::uintmax_t       uintmax       = UINTMAX_C(4294967295);
-#endif
-
-  BOOST_TEST( int8 == -127 );
-  BOOST_TEST( int_least8 == -127 );
-  BOOST_TEST( int_fast8 == -127 );
-  BOOST_TEST( uint8 == 255u );
-  BOOST_TEST( uint_least8 == 255u );
-  BOOST_TEST( uint_fast8 == 255u );
-  BOOST_TEST( int16 == -32767 );
-  BOOST_TEST( int_least16 == -32767 );
-  BOOST_TEST( int_fast16 == -32767 );
-  BOOST_TEST( uint16 == 65535u );
-  BOOST_TEST( uint_least16 == 65535u );
-  BOOST_TEST( uint_fast16 == 65535u );
-  BOOST_TEST( int32 == -2147483647 );
-  BOOST_TEST( int_least32 == -2147483647 );
-  BOOST_TEST( int_fast32 == -2147483647 );
-  BOOST_TEST( uint32 == 4294967295u );
-  BOOST_TEST( uint_least32 == 4294967295u );
-  BOOST_TEST( uint_fast32 == 4294967295u );
-
-#ifndef BOOST_NO_INT64_T
-  BOOST_TEST( int64 == INT64_C(-9223372036854775807) );
-  BOOST_TEST( int_least64 == INT64_C(-9223372036854775807) );
-  BOOST_TEST( int_fast64 == INT64_C(-9223372036854775807) );
-  BOOST_TEST( uint64 == UINT64_C(18446744073709551615) );
-  BOOST_TEST( uint_least64 == UINT64_C(18446744073709551615) );
-  BOOST_TEST( uint_fast64 == UINT64_C(18446744073709551615) );
-  BOOST_TEST( intmax == INT64_C(-9223372036854775807) );
-  BOOST_TEST( uintmax == UINT64_C(18446744073709551615) );
-#else
-  BOOST_TEST( intmax == -2147483647 );
-  BOOST_TEST( uintmax == 4294967295u );
-#endif
-
-
-  std::cout << "OK\n";
-  return boost::report_errors();
-}

test/extended_euclidean_test.cpp

@@ -0,0 +1,58 @@
+/*
+ *  (C) Copyright Nick Thompson 2018.
+ *  Use, modification and distribution are subject to the
+ *  Boost Software License, Version 1.0. (See accompanying file
+ *  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#include "multiprecision_config.hpp"
+
+#ifndef DISABLE_MP_TESTS
+#include <boost/integer/extended_euclidean.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/multiprecision/cpp_int.hpp>
+#include <boost/integer/common_factor.hpp>
+
+using boost::multiprecision::int128_t;
+using boost::multiprecision::int256_t;
+using boost::integer::extended_euclidean;
+using boost::integer::gcd;
+
+template<class Z>
+void test_extended_euclidean()
+{
+    // Stress test:
+    //Z max_arg = std::numeric_limits<Z>::max();
+    Z max_arg = 500;
+    for (Z m = max_arg; m > 0; --m)
+    {
+        for (Z n = max_arg; n > 0; --n)
+        {
+            boost::integer::euclidean_result_t<Z> u = extended_euclidean(m, n);
+            int256_t gcdmn = gcd(m, n);
+            int256_t x = u.x;
+            int256_t y = u.y;
+            BOOST_TEST_EQ(u.gcd, gcdmn);
+            BOOST_TEST_EQ(m*x + n*y, gcdmn);
+        }
+    }
+}
+
+
+
+int main()
+{
+    test_extended_euclidean<boost::int16_t>();
+    test_extended_euclidean<boost::int32_t>();
+    test_extended_euclidean<boost::int64_t>();
+    test_extended_euclidean<int128_t>();
+
+    return boost::report_errors();;
+}
+#else
+int main()
+{
+    return 0;
+}
+#endif

test/fail_int_exact.cpp

@@ -0,0 +1,8 @@
+//  Copyright John Maddock 2012.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer.hpp>
+
+typedef boost::int_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::exact fail_int_exact;

test/fail_int_fast.cpp

@@ -0,0 +1,8 @@
+//  Copyright John Maddock 2012.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer.hpp>
+
+typedef boost::int_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::fast fail_int_fast;

test/fail_int_least.cpp

@@ -0,0 +1,8 @@
+//  Copyright John Maddock 2012.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer.hpp>
+
+typedef boost::int_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::least fail_int_least;

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 https://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;
+}

test/fail_uint_exact.cpp

@@ -0,0 +1,8 @@
+//  Copyright John Maddock 2012.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer.hpp>
+
+typedef boost::uint_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::exact fail_uint_exact;

test/fail_uint_fast.cpp

@@ -0,0 +1,8 @@
+//  Copyright John Maddock 2012.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer.hpp>
+
+typedef boost::uint_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::fast fail_uint_fast;

test/fail_uint_least.cpp

@@ -0,0 +1,8 @@
+//  Copyright John Maddock 2012.  
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/integer.hpp>
+
+typedef boost::uint_t<sizeof(boost::intmax_t)*CHAR_BIT + 1>::least fail_uint_least;

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
+//  https://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
+
+

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
+//  https://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
+

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 https://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

test/integer_fwd_include_test.cpp

@@ -1,7 +1,7 @@
 //  Copyright John Maddock 2009.  
 //  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)
+//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/integer_fwd.hpp> // must be the only #include!
 

test/integer_include_test.cpp

@@ -1,7 +1,7 @@
 //  Copyright John Maddock 2009.  
 //  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)
+//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/integer.hpp> // must be the only #include!
 

test/integer_log2_test.cpp

@@ -0,0 +1,187 @@
+//  Boost integer_log2.hpp test program  --------------------------------------//
+
+//  (C) Copyright Andrey Semashev 2021.
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  https://www.boost.org/LICENSE_1_0.txt)
+
+//  See https://www.boost.org for most recent version including documentation.
+
+#include <boost/config.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/integer/integer_log2.hpp>
+
+#include <boost/core/lightweight_test.hpp>
+
+#include <iostream>
+
+#include "multiprecision_config.hpp"
+
+#if !defined(DISABLE_MP_TESTS)
+#include <boost/multiprecision/cpp_int.hpp>
+#endif
+
+// Macros to compact code
+#define PRIVATE_LB_TEST( v, e )  BOOST_TEST( ::boost::integer_log2((v)) == e )
+
+#define PRIVATE_PRINT_LB( v )    ::std::cout << "boost::integer_log2(" << (v) \
+ << ") = " << ::boost::integer_log2((v)) << '.' << ::std::endl
+
+// Control to check for a compile-time error
+#ifndef CONTROL_LB_0_TEST
+#define PRIVATE_LB_0_TEST
+#else
+#define PRIVATE_LB_0_TEST  PRIVATE_PRINT_LB( 0 )
+#endif
+
+// Main testing function
+int main()
+{
+    std::cout << "Doing tests on integer_log2." << std::endl;
+
+    PRIVATE_LB_0_TEST;
+
+    PRIVATE_LB_TEST( (unsigned char)1, 0 );
+    PRIVATE_LB_TEST( (unsigned char)2, 1 );
+
+    PRIVATE_LB_TEST( 1, 0 );
+
+    PRIVATE_LB_TEST( 2, 1 );
+    PRIVATE_LB_TEST( 3, 1 );
+
+    PRIVATE_LB_TEST( 4, 2 );
+    PRIVATE_LB_TEST( 5, 2 );
+    PRIVATE_LB_TEST( 6, 2 );
+    PRIVATE_LB_TEST( 7, 2 );
+
+    PRIVATE_LB_TEST(  8, 3 );
+    PRIVATE_LB_TEST(  9, 3 );
+    PRIVATE_LB_TEST( 10, 3 );
+    PRIVATE_LB_TEST( 11, 3 );
+    PRIVATE_LB_TEST( 12, 3 );
+    PRIVATE_LB_TEST( 13, 3 );
+    PRIVATE_LB_TEST( 14, 3 );
+    PRIVATE_LB_TEST( 15, 3 );
+
+    PRIVATE_LB_TEST( 16, 4 );
+    PRIVATE_LB_TEST( 17, 4 );
+    PRIVATE_LB_TEST( 18, 4 );
+    PRIVATE_LB_TEST( 19, 4 );
+    PRIVATE_LB_TEST( 20, 4 );
+    PRIVATE_LB_TEST( 21, 4 );
+    PRIVATE_LB_TEST( 22, 4 );
+    PRIVATE_LB_TEST( 23, 4 );
+    PRIVATE_LB_TEST( 24, 4 );
+    PRIVATE_LB_TEST( 25, 4 );
+    PRIVATE_LB_TEST( 26, 4 );
+    PRIVATE_LB_TEST( 27, 4 );
+    PRIVATE_LB_TEST( 28, 4 );
+    PRIVATE_LB_TEST( 29, 4 );
+    PRIVATE_LB_TEST( 30, 4 );
+    PRIVATE_LB_TEST( 31, 4 );
+
+    PRIVATE_LB_TEST( 32, 5 );
+    PRIVATE_LB_TEST( 33, 5 );
+    PRIVATE_LB_TEST( 34, 5 );
+    PRIVATE_LB_TEST( 35, 5 );
+    PRIVATE_LB_TEST( 36, 5 );
+    PRIVATE_LB_TEST( 37, 5 );
+    PRIVATE_LB_TEST( 38, 5 );
+    PRIVATE_LB_TEST( 39, 5 );
+    PRIVATE_LB_TEST( 40, 5 );
+
+    PRIVATE_LB_TEST( 63, 5 );
+
+    PRIVATE_LB_TEST( 64, 6 );
+    PRIVATE_LB_TEST( 65, 6 );
+
+    PRIVATE_LB_TEST( 127, 6 );
+
+    PRIVATE_LB_TEST( 128, 7 );
+    PRIVATE_LB_TEST( 129, 7 );
+
+    PRIVATE_LB_TEST( 255, 7 );
+
+    PRIVATE_LB_TEST( 256, 8 );
+    PRIVATE_LB_TEST( 257, 8 );
+
+    PRIVATE_LB_TEST( 511, 8 );
+
+    PRIVATE_LB_TEST( 512, 9 );
+    PRIVATE_LB_TEST( 513, 9 );
+
+    PRIVATE_LB_TEST( 1023, 9 );
+
+    PRIVATE_LB_TEST( 1024, 10 );
+    PRIVATE_LB_TEST( 1025, 10 );
+
+    PRIVATE_LB_TEST( 2047, 10 );
+
+    PRIVATE_LB_TEST( 2048, 11 );
+    PRIVATE_LB_TEST( 2049, 11 );
+
+    PRIVATE_LB_TEST( 4095, 11 );
+
+    PRIVATE_LB_TEST( 4096, 12 );
+    PRIVATE_LB_TEST( 4097, 12 );
+
+    PRIVATE_LB_TEST( 8191, 12 );
+
+    PRIVATE_LB_TEST( 8192, 13 );
+    PRIVATE_LB_TEST( 8193, 13 );
+
+    PRIVATE_LB_TEST( 16383, 13 );
+
+    PRIVATE_LB_TEST( 16384, 14 );
+    PRIVATE_LB_TEST( 16385, 14 );
+
+    PRIVATE_LB_TEST( 32767, 14 );
+
+    PRIVATE_LB_TEST( 32768, 15 );
+    PRIVATE_LB_TEST( 32769, 15 );
+
+    PRIVATE_LB_TEST( 65535, 15 );
+
+    PRIVATE_LB_TEST( 65536, 16 );
+    PRIVATE_LB_TEST( 65537, 16 );
+
+#if defined(UINT32_C)
+    PRIVATE_LB_TEST( UINT32_C(4294967295), 31 );
+#endif
+
+#if defined(UINT64_C) && !defined(BOOST_NO_INT64_T)
+    PRIVATE_LB_TEST( UINT64_C(4294967296), 32 );
+    PRIVATE_LB_TEST( UINT64_C(4294967297), 32 );
+
+    PRIVATE_LB_TEST( UINT64_C(18446744073709551615), 63 );
+#endif
+
+#if defined(BOOST_HAS_INT128)
+    PRIVATE_LB_TEST( boost::uint128_type(1u) << 64u, 64 );
+    PRIVATE_LB_TEST( (boost::uint128_type(1u) << 64u) + 1u, 64 );
+
+    PRIVATE_LB_TEST( ~boost::uint128_type(0u), 127 );
+#endif
+
+#if !defined(DISABLE_MP_TESTS)
+    PRIVATE_LB_TEST( boost::multiprecision::cpp_int(1), 0 );
+    PRIVATE_LB_TEST( boost::multiprecision::cpp_int(2), 1 );
+    PRIVATE_LB_TEST( boost::multiprecision::cpp_int(3), 1 );
+    PRIVATE_LB_TEST( boost::multiprecision::cpp_int(65535), 15 );
+    PRIVATE_LB_TEST( boost::multiprecision::cpp_int(65536), 16 );
+
+    PRIVATE_LB_TEST( boost::multiprecision::int1024_t(1), 0 );
+    PRIVATE_LB_TEST( boost::multiprecision::int1024_t(2), 1 );
+    PRIVATE_LB_TEST( boost::multiprecision::int1024_t(3), 1 );
+    PRIVATE_LB_TEST( boost::multiprecision::int1024_t(65535), 15 );
+    PRIVATE_LB_TEST( boost::multiprecision::int1024_t(65536), 16 );
+
+    PRIVATE_LB_TEST( boost::multiprecision::uint1024_t(1), 0 );
+    PRIVATE_LB_TEST( boost::multiprecision::uint1024_t(2), 1 );
+    PRIVATE_LB_TEST( boost::multiprecision::uint1024_t(3), 1 );
+    PRIVATE_LB_TEST( boost::multiprecision::uint1024_t(65535), 15 );
+    PRIVATE_LB_TEST( boost::multiprecision::uint1024_t(65536), 16 );
+#endif
+
+    return boost::report_errors();
+}

test/integer_mask_include_test.cpp

@@ -1,7 +1,7 @@
 //  Copyright John Maddock 2009.  
 //  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)
+//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/integer/integer_mask.hpp> // must be the only #include!
 

test/integer_mask_test.cpp

@@ -3,14 +3,14 @@
 //  (C) Copyright Daryle Walker 2001.
 //  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)
+//  https://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org for most recent version including documentation.
+//  See https://www.boost.org for most recent version including documentation.
 
 //  Revision History
 //  23 Sep 2001  Initial version (Daryle Walker)
 
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 #include <boost/cstdlib.hpp>               // for boost::exit_success
 #include <boost/integer/integer_mask.hpp>  // for boost::high_bit_mask_t, etc.

test/integer_test.cpp

@@ -5,19 +5,20 @@
 //  Copyright John Maddock 2009.  
 //  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)
+//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
 
-//  See http://www.boost.org/libs/integer for documentation.
+//  See https://www.boost.org/libs/integer for documentation.
 
 //  Revision History
 //   04 Oct 01  Added tests for new templates; rewrote code (Daryle Walker)
 //   10 Mar 01  Boost Test Library now used for tests (Beman Dawes)
 //   31 Aug 99  Initial version
 
-#include <boost/detail/lightweight_test.hpp>  // for main, BOOST_TEST
+#include <boost/core/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)
@@ -26,7 +27,7 @@
 #ifdef BOOST_MSVC
 #pragma warning(disable:4127) // conditional expression is constant
 #endif
-#if defined( __BORLANDC__ )
+#if defined( BOOST_BORLANDC )
 # pragma option -w-8008 -w-8066 // condition is always true
 #endif
 

test/integer_traits_include_test.cpp

@@ -1,7 +1,7 @@
 //  Copyright John Maddock 2009.  
 //  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)
+//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/integer_traits.hpp> // must be the only #include!
 

test/integer_traits_test.cpp

@@ -3,7 +3,7 @@
  * Copyright Jens Maurer 2000
  * 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)
+ * https://www.boost.org/LICENSE_1_0.txt)
  *
  * $Id$
  *
@@ -17,7 +17,7 @@
 // use int64_t instead of long long for better portability
 #include <boost/cstdint.hpp>
 
-#include <boost/detail/lightweight_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 /*
  * General portability note:
@@ -35,6 +35,7 @@ namespace fix{
 inline int make_char_numeric_for_streaming(char c) { return c; }
 inline int make_char_numeric_for_streaming(signed char c) { return c; }
 inline int make_char_numeric_for_streaming(unsigned char c) { return c; }
+inline long long int make_char_numeric_for_streaming(wchar_t c) { return c; }
 }
 using namespace fix;
 #else
@@ -42,6 +43,7 @@ template<typename T> inline T make_char_numeric_for_streaming(T x) { return x; }
 inline int make_char_numeric_for_streaming(char c) { return c; }
 inline int make_char_numeric_for_streaming(signed char c) { return c; }
 inline int make_char_numeric_for_streaming(unsigned char c) { return c; }
+inline long long int make_char_numeric_for_streaming(wchar_t c) { return c; }
 #endif
 
 template<class T>

test/mod_inverse_test.cpp

@@ -0,0 +1,71 @@
+/*
+ *  (C) Copyright Nick Thompson 2018.
+ *  Use, modification and distribution are subject to the
+ *  Boost Software License, Version 1.0. (See accompanying file
+ *  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#include "multiprecision_config.hpp"
+
+#ifndef DISABLE_MP_TESTS
+#include <boost/integer/mod_inverse.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/optional/optional.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/multiprecision/cpp_int.hpp>
+#include <boost/integer/common_factor.hpp>
+
+using boost::multiprecision::int128_t;
+using boost::multiprecision::int256_t;
+using boost::integer::mod_inverse;
+using boost::integer::gcd;
+
+template<class Z>
+void test_mod_inverse()
+{
+    //Z max_arg = std::numeric_limits<Z>::max();
+    Z max_arg = 500;
+    for (Z modulus = 2; modulus < max_arg; ++modulus)
+    {
+        if (modulus % 1000 == 0)
+        {
+            std::cout << "Testing all inverses modulo " << modulus << std::endl;
+        }
+        for (Z a = 1; a < modulus; ++a)
+        {
+            Z gcdam = gcd(a, modulus);
+            Z inv_a = mod_inverse(a, modulus);
+            // Should fail if gcd(a, mod) != 1:
+            if (gcdam > 1)
+            {
+                BOOST_TEST(inv_a == 0);
+            }
+            else
+            {
+                BOOST_TEST(inv_a > 0);
+                // Cast to a bigger type so the multiplication won't overflow.
+                int256_t a_inv = inv_a;
+                int256_t big_a = a;
+                int256_t m = modulus;
+                int256_t outta_be_one = (a_inv*big_a) % m;
+                BOOST_TEST_EQ(outta_be_one, 1);
+            }
+        }
+    }
+}
+
+int main()
+{
+    test_mod_inverse<boost::int16_t>();
+    test_mod_inverse<boost::int32_t>();
+    test_mod_inverse<boost::int64_t>();
+    test_mod_inverse<int128_t>();
+
+    return boost::report_errors();
+}
+#else
+int main()
+{
+  return 0;
+}
+#endif

test/multiprecision_config.hpp

@@ -0,0 +1,33 @@
+// Copyright (c) 2018 Andrey Semashev
+//
+// Use, modification, and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_INTEGER_TEST_MULTIPRECISION_CONFIG_HPP_INCLUDED_
+#define BOOST_INTEGER_TEST_MULTIPRECISION_CONFIG_HPP_INCLUDED_
+
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+
+#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
+
+// This list of checks matches those in Boost.Multiprecision, boost/multiprecision/detail/number_base.hpp,
+// as it no longer supports C++03 since 2021.
+#if !defined(DISABLE_MP_TESTS) && \
+    (\
+        defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) || defined(BOOST_NO_CXX11_HDR_ARRAY) || defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)\
+        || defined(BOOST_NO_CXX11_ALLOCATOR) || defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) || defined(BOOST_NO_CXX11_CONSTEXPR)\
+        || (defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) || BOOST_WORKAROUND(__SUNPRO_CC, < 0x5140)) || defined(BOOST_NO_CXX11_REF_QUALIFIERS) || defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)\
+        || defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_NO_CXX11_USER_DEFINED_LITERALS) || defined(BOOST_NO_CXX11_THREAD_LOCAL)\
+        || defined(BOOST_NO_CXX11_DECLTYPE) || defined(BOOST_NO_CXX11_STATIC_ASSERT) || defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)\
+        || defined(BOOST_NO_CXX11_NOEXCEPT) || defined(BOOST_NO_CXX11_REF_QUALIFIERS)\
+    )
+#define DISABLE_MP_TESTS
+#endif
+
+#endif // BOOST_INTEGER_TEST_MULTIPRECISION_CONFIG_HPP_INCLUDED_

test/static_log2_include_test.cpp

@@ -1,7 +1,7 @@
 //  Copyright John Maddock 2009.  
 //  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)
+//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/integer/static_log2.hpp> // must be the only #include!
 

test/static_log2_test.cpp

@@ -3,14 +3,14 @@
 //  (C) Copyright Daryle Walker 2001.
 //  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)
+//  https://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org for most recent version including documentation.
+//  See https://www.boost.org for most recent version including documentation.
 
 //  Revision History
 //  01 Oct 2001  Initial version (Daryle Walker)
 
-#include <boost/detail/lightweight_test.hpp>  // for main
+#include <boost/core/lightweight_test.hpp>  // for main
 
 #include <boost/cstdlib.hpp>              // for boost::exit_success
 #include <boost/integer/static_log2.hpp>  // for boost::static_log2

test/static_min_max_include_test.cpp

@@ -1,7 +1,7 @@
 //  Copyright John Maddock 2009.  
 //  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)
+//  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/integer/static_min_max.hpp> // must be the only #include!
 

test/static_min_max_test.cpp

@@ -3,14 +3,14 @@
 //  (C) Copyright Daryle Walker 2001.
 //  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)
+//  https://www.boost.org/LICENSE_1_0.txt)
 
-//  See http://www.boost.org for most recent version including documentation.
+//  See https://www.boost.org for most recent version including documentation.
 
 //  Revision History
 //  23 Sep 2001  Initial version (Daryle Walker)
 
-#include <boost/detail/lightweight_test.hpp>  // for main, BOOST_TEST
+#include <boost/core/lightweight_test.hpp>  // for main, BOOST_TEST
 
 #include <boost/cstdlib.hpp>                 // for boost::exit_success
 #include <boost/integer/static_min_max.hpp>  // for boost::static_signed_min, etc.