diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 1701c3cfa..2afef5145 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,9 +1,23 @@
-# Copyright 2021-2022 Andrey Semashev
-# Copyright 2023 Matt Borland
+#
+# Copyright 2020-2021 Peter Dimov
+# Copyright 2021 Andrey Semashev
+# Copyright 2021-2026 Alexander Grund
+# Copyright 2022-2025 James E. King III
+#
 # 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
+#
+# This workflow uses the Boost.CI reusable workflow which builds a variety of
+# configurations of your project, runs tests, and generates code coverage reports.
+#
+# To use it, copy this file into your repository as `.github/workflows/ci.yml` and
+# customize it appropriately.
+# 
+---
+name: Boost.CI
+
+permissions:
+  contents: read
 
 on:
   pull_request:
@@ -11,557 +25,31 @@ on:
     branches:
       - master
       - develop
+      - bugfix/**
       - 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
+      - fix/**
+      - github/**
+      - pr/**
+    paths-ignore:
+      - LICENSE
+      - meta/**
+      - README.md
 
 jobs:
-  posix:
-    defaults:
-      run:
-        shell: bash
-
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - toolset: gcc-5
-            cxxstd: "03,11,14,1z"
-            address_model: 32,64
-            os: ubuntu-latest
-            container: ubuntu:16.04
-            install:
-              - g++-5-multilib
-          - toolset: gcc-5
-            cxxstd: "11-gnu,14-gnu,1z-gnu"
-            address_model: 32,64
-            os: ubuntu-latest
-            container: ubuntu:16.04
-            install:
-              - g++-5-multilib
-          - toolset: gcc-6
-            cxxstd: "11,14,1z"
-            address_model: 32,64
-            os: ubuntu-latest
-            container: ubuntu:18.04
-            install:
-              - g++-6-multilib
-          - toolset: gcc-7
-            cxxstd: "11,14,17"
-            address_model: 32,64
-            os: ubuntu-latest
-            container: ubuntu:18.04
-            install:
-              - g++-7-multilib
-          - toolset: gcc-8
-            cxxstd: "11,14,17,2a"
-            address_model: 32,64
-            os: ubuntu-latest
-            container: ubuntu:18.04
-            install:
-              - g++-8-multilib
-          - toolset: gcc-9
-            cxxstd: "11,14,17,2a"
-            address_model: 32,64
-            os: ubuntu-latest
-            container: ubuntu:20.04
-            install:
-              - g++-9-multilib
-          - toolset: gcc-9
-            cxxstd: "11-gnu,14-gnu,17-gnu,2a-gnu"
-            address_model: 32,64
-            os: ubuntu-latest
-            container: ubuntu:20.04
-            install:
-              - g++-9-multilib
-          - toolset: gcc-10
-            cxxstd: "11,14,17,20"
-            address_model: 32,64
-            os: ubuntu-latest
-            container: ubuntu:20.04
-            install:
-              - g++-10-multilib
-          - toolset: gcc-11
-            cxxstd: "11,14,17,20,23"
-            address_model: 32,64
-            os: ubuntu-latest
-            container: ubuntu:22.04
-            install:
-              - g++-11-multilib
-          - toolset: gcc-12
-            cxxstd: "11,14,17,20,23"
-            address_model: 32,64
-            os: ubuntu-latest
-            container: ubuntu:22.04
-            install:
-              - g++-12-multilib
-          - toolset: gcc-12
-            cxxstd: "11-gnu,14-gnu,17-gnu,20-gnu,23-gnu"
-            address_model: 32,64
-            os: ubuntu-latest
-            container: ubuntu:22.04
-            install:
-              - g++-12-multilib
-
-          # Linux, clang
-          - 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-latest
-            container: ubuntu:20.04
-            install:
-              - clang-9
-          - toolset: clang
-            compiler: clang++-10
-            cxxstd: "11,14,17,20"
-            os: ubuntu-latest
-            container: ubuntu:20.04
-            install:
-              - clang-10
-          - toolset: clang
-            compiler: clang++-11
-            cxxstd: "11,14,17,20"
-            os: ubuntu-latest
-            container: ubuntu:22.04
-            install:
-              - clang-11
-          - toolset: clang
-            compiler: clang++-12
-            cxxstd: "11,14,17,20"
-            os: ubuntu-latest
-            container: ubuntu:22.04
-            install:
-              - clang-12
-          - toolset: clang
-            compiler: clang++-13
-            cxxstd: "11,14,17,20"
-            os: ubuntu-latest
-            container: ubuntu:22.04
-            install:
-              - clang-13
-          - toolset: clang
-            compiler: clang++-14
-            cxxstd: "11,14,17,20"
-            os: ubuntu-latest
-            container: ubuntu:22.04
-            install:
-              - clang-14
-          - toolset: clang
-            compiler: clang++-14
-            cxxstd: "11-gnu,14-gnu,17-gnu,20-gnu"
-            os: ubuntu-latest
-            container: ubuntu:22.04
-            install:
-              - clang-14
-          - toolset: clang
-            compiler: clang++-15
-            cxxstd: "11,14,17,20"
-            os: ubuntu-latest
-            container: ubuntu:22.04
-            install:
-              - clang-15
-            sources:
-              - "deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-15 main"
-            source_keys:
-              - "https://apt.llvm.org/llvm-snapshot.gpg.key"
-          - toolset: clang
-            compiler: clang++-15
-            cxxstd: "11,14,17,20,2b"
-            os: ubuntu-latest
-            container: ubuntu:22.04
-            install:
-              - clang-15
-              - libc++-15-dev
-              - libc++abi-15-dev
-            sources:
-              - "deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-15 main"
-            source_keys:
-              - "https://apt.llvm.org/llvm-snapshot.gpg.key"
-            cxxflags: -stdlib=libc++
-            linkflags: -stdlib=libc++
-
-          - toolset: clang
-            cxxstd: "11,14,17,20,2b"
-            os: macos-14
-          - toolset: clang
-            cxxstd: "11,14,17,20,2b"
-            os: macos-15
-
-    timeout-minutes: 360
-    runs-on: ${{matrix.os}}
-    container:
-      image: ${{matrix.container}}
-      volumes:
-        - /node20217:/node20217:rw,rshared
-        - ${{ startsWith(matrix.container, 'ubuntu:1') && '/node20217:/__e/node20:ro,rshared' || ' ' }}
-
-    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
-              if [[ "${{matrix.container}}" == "ubuntu:1"* ]]; then
-                # Node 20 doesn't work with Ubuntu 16/18  glibc: https://github.com/actions/checkout/issues/1590
-                curl -sL https://archives.boost.io/misc/node/node-v20.9.0-linux-x64-glibc-217.tar.xz | tar -xJ --strip-components 1 -C /node20217
-              fi
-          fi
-          git config --global pack.threads 0
-      - uses: actions/checkout@v4
-
-      - 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}}" "link=static,shared")
-          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
-          if [ -n "${{matrix.address_model}}" ]
-          then
-              B2_ARGS+=("address-model=${{matrix.address_model}}")
-          fi
-          B2_ARGS+=("libs/$LIBRARY/test")
-          ./b2 "${B2_ARGS[@]}"
-
-  windows:
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - toolset: msvc-14.3
-            cxxstd: "17,20,latest"
-            addrmd: 64
-            os: windows-2022
-          - toolset: clang-win
-            cxxstd: "14,17,latest"
-            addrmd: 64
-            os: windows-2022
-          - toolset: gcc
-            cxxstd: "11,14,17,2a"
-            addrmd: 64
-            os: windows-latest
-
-    runs-on: ${{matrix.os}}
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Setup Boost
-        shell: cmd
-        run: |
-          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
-          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
-          echo LIBRARY: %LIBRARY%
-          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
-          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
-          echo GITHUB_REF: %GITHUB_REF%
-          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
-          set BOOST_BRANCH=develop
-          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
-          echo BOOST_BRANCH: %BOOST_BRANCH%
-          cd ..
-          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
-          cd boost-root
-          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
-          git submodule update --init tools/boostdep
-          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
-          cmd /c bootstrap
-          b2 -d0 headers
-
-      - name: Run tests
-        shell: cmd
-        run: |
-          cd ../boost-root
-          b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=release link=static,shared embed-manifest-via=linker
-
-  posix-cmake-test:
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: ubuntu-24.04
-          - os: macos-14
-          - os: macos-15
-
-    runs-on: ${{matrix.os}}
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Install packages
-        if: matrix.install
-        run: sudo apt-get -y install ${{matrix.install}}
-
-      - 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
-          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
-          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
-
-      - name: Configure
-        run: |
-          cd ../boost-root
-          mkdir __build__ && cd __build__
-          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DBUILD_TESTING=ON ..
-
-      - name: Build tests
-        run: |
-          cd ../boost-root/__build__
-          cmake --build . --target tests
-
-      - name: Run tests
-        run: |
-          cd ../boost-root/__build__
-          ctest --output-on-failure --no-tests=error
+  call-boost-ci:
+    name: Run Boost.CI
+    uses: boostorg/boost-ci/.github/workflows/reusable.yml@master
+    with:
+      branch_coverage: false
+      enable_multiarch: false
+      enable_sanitizers: false
+      exclude_compiler: gcc-4.7,icpx-2025
+      exclude_os: windows-11-arm
+      exclude_jobs: |
+        # Don't collect coverage on Windows, Ubuntu only
+        os: windows, coverage: yes
+      timeout: 180
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      COVERITY_SCAN_NOTIFICATION_EMAIL: ${{ secrets.COVERITY_SCAN_NOTIFICATION_EMAIL }}
+      COVERITY_SCAN_TOKEN: ${{ secrets.COVERITY_SCAN_TOKEN }}
diff --git a/extra/haertel.hpp b/extra/haertel.hpp
index c318d805b..ff346f871 100644
--- a/extra/haertel.hpp
+++ b/extra/haertel.hpp
@@ -18,7 +18,7 @@
 #ifndef BOOST_RANDOM_HAERTEL_HPP
 #define BOOST_RANDOM_HAERTEL_HPP
 
-#include <boost/cstdint.hpp>
+#include <cstdint>
 #include <boost/random/linear_congruential.hpp>
 #include <boost/random/inversive_congruential.hpp>
 
@@ -127,29 +127,29 @@ class lagged_fibonacci_int
 // distributions from Haertel's dissertation
 // (additional parameterizations of the basic templates)
 namespace Haertel {
-  typedef boost::random::linear_congruential<boost::uint64_t, 45965, 453816691,
-    (boost::uint64_t(1)<<31), 0> LCG_Af2;
-  typedef boost::random::linear_congruential<boost::uint64_t, 211936855, 0,
-    (boost::uint64_t(1)<<29)-3, 0> LCG_Die1;
-  typedef boost::random::linear_congruential<boost::uint32_t, 2824527309u, 0,
+  typedef boost::random::linear_congruential<std::uint64_t, 45965, 453816691,
+    (std::uint64_t(1)<<31), 0> LCG_Af2;
+  typedef boost::random::linear_congruential<std::uint64_t, 211936855, 0,
+    (std::uint64_t(1)<<29)-3, 0> LCG_Die1;
+  typedef boost::random::linear_congruential<std::uint32_t, 2824527309u, 0,
     0, 0> LCG_Fis;
-  typedef boost::random::linear_congruential<boost::uint64_t, 950706376u, 0,
-    (boost::uint64_t(1)<<31)-1, 0> LCG_FM;
-  typedef boost::random::linear_congruential<boost::int32_t, 51081, 0,
+  typedef boost::random::linear_congruential<std::uint64_t, 950706376u, 0,
+    (std::uint64_t(1)<<31)-1, 0> LCG_FM;
+  typedef boost::random::linear_congruential<std::int32_t, 51081, 0,
     2147483647, 0> LCG_Hae;
-  typedef boost::random::linear_congruential<boost::uint32_t, 69069, 1,
+  typedef boost::random::linear_congruential<std::uint32_t, 69069, 1,
     0, 0> LCG_VAX;
-  typedef boost::random::inversive_congruential<boost::int64_t, 240318, 197, 
+  typedef boost::random::inversive_congruential<std::int64_t, 240318, 197, 
     1000081, 0> NLG_Inv1;
-  typedef boost::random::inversive_congruential<boost::int64_t, 15707262,
+  typedef boost::random::inversive_congruential<std::int64_t, 15707262,
     13262967, (1<<24)-17, 0> NLG_Inv2;
-  typedef boost::random::inversive_congruential<boost::int32_t, 1, 1,
+  typedef boost::random::inversive_congruential<std::int32_t, 1, 1,
     2147483647, 0> NLG_Inv4;
-  typedef boost::random::inversive_congruential<boost::int32_t, 1, 2,
+  typedef boost::random::inversive_congruential<std::int32_t, 1, 2,
     1<<30, 0> NLG_Inv5;
-  typedef boost::random::additive_congruential<boost::int32_t, 6,
+  typedef boost::random::additive_congruential<std::int32_t, 6,
     (1<<30)-35, 0> MRG_Acorn7;
-  typedef boost::random::lagged_fibonacci_int<boost::uint32_t, 607, 273,
+  typedef boost::random::lagged_fibonacci_int<std::uint32_t, 607, 273,
     0, 0> MRG_Fib2;
 } // namespace Haertel
 
diff --git a/include/boost/random/additive_combine.hpp b/include/boost/random/additive_combine.hpp
index ba045aded..94c2b489f 100644
--- a/include/boost/random/additive_combine.hpp
+++ b/include/boost/random/additive_combine.hpp
@@ -16,11 +16,11 @@
 #ifndef BOOST_RANDOM_ADDITIVE_COMBINE_HPP
 #define BOOST_RANDOM_ADDITIVE_COMBINE_HPP
 
+#include <cstdint>
 #include <istream>
 #include <iosfwd>
 #include <algorithm> // for std::min and std::max
 #include <boost/config.hpp>
-#include <boost/cstdint.hpp>
 #include <boost/random/detail/config.hpp>
 #include <boost/random/detail/operators.hpp>
 #include <boost/random/detail/seed.hpp>
@@ -196,7 +196,7 @@ class additive_combine_engine
     { detail::generate_from_int(*this, first, last); }
 
     /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z)
+    void discard(std::uintmax_t z)
     {
         _mlcg1.discard(z);
         _mlcg2.discard(z);
diff --git a/include/boost/random/binomial_distribution.hpp b/include/boost/random/binomial_distribution.hpp
index a98d53b51..53b0b57d8 100644
--- a/include/boost/random/binomial_distribution.hpp
+++ b/include/boost/random/binomial_distribution.hpp
@@ -16,6 +16,7 @@
 #include <boost/config/no_tr1/cmath.hpp>
 #include <cstdlib>
 #include <iosfwd>
+#include <limits>
 
 #include <boost/random/detail/config.hpp>
 #include <boost/random/uniform_01.hpp>
diff --git a/include/boost/random/cauchy_distribution.hpp b/include/boost/random/cauchy_distribution.hpp
index 998e52344..864bdf3a7 100644
--- a/include/boost/random/cauchy_distribution.hpp
+++ b/include/boost/random/cauchy_distribution.hpp
@@ -19,7 +19,7 @@
 #include <boost/config/no_tr1/cmath.hpp>
 #include <iosfwd>
 #include <istream>
-#include <boost/limits.hpp>
+#include <limits>
 #include <boost/random/detail/config.hpp>
 #include <boost/random/detail/operators.hpp>
 #include <boost/random/uniform_01.hpp>
diff --git a/include/boost/random/chi_squared_distribution.hpp b/include/boost/random/chi_squared_distribution.hpp
index f0fcce5c5..198b3d0be 100644
--- a/include/boost/random/chi_squared_distribution.hpp
+++ b/include/boost/random/chi_squared_distribution.hpp
@@ -14,7 +14,7 @@
 #define BOOST_RANDOM_CHI_SQUARED_DISTRIBUTION_HPP_INCLUDED
 
 #include <iosfwd>
-#include <boost/limits.hpp>
+#include <limits>
 
 #include <boost/random/detail/config.hpp>
 #include <boost/random/gamma_distribution.hpp>
diff --git a/include/boost/random/detail/const_mod.hpp b/include/boost/random/detail/const_mod.hpp
index e0a43ab24..557d56596 100644
--- a/include/boost/random/detail/const_mod.hpp
+++ b/include/boost/random/detail/const_mod.hpp
@@ -16,6 +16,8 @@
 #ifndef BOOST_RANDOM_CONST_MOD_HPP
 #define BOOST_RANDOM_CONST_MOD_HPP
 
+#include <cstdint>
+#include <limits>
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/integer_traits.hpp>
@@ -84,7 +86,7 @@ class const_mod
       return add(mult(a, x), c);
   }
 
-  static IntType pow(IntType a, boost::uintmax_t exponent)
+  static IntType pow(IntType a, std::uintmax_t exponent)
   {
       IntType result = 1;
       while(exponent != 0) {
@@ -129,10 +131,10 @@ class const_mod
     BOOST_ASSERT(suppress_warnings == 0);
     IntType modulus = m + suppress_warnings;
     BOOST_ASSERT(modulus == m);
-    if(::boost::uintmax_t(modulus) <=
-        (::std::numeric_limits< ::boost::uintmax_t>::max)() / modulus)
+    if(std::uintmax_t(modulus) <=
+        (std::numeric_limits< std::uintmax_t>::max)() / modulus)
     {
-      return static_cast<IntType>(boost::uintmax_t(a) * b % modulus);
+      return static_cast<IntType>(std::uintmax_t(a) * b % modulus);
     } else {
       return static_cast<IntType>(detail::mulmod(a, b, modulus));
     }
diff --git a/include/boost/random/detail/generator_bits.hpp b/include/boost/random/detail/generator_bits.hpp
index 05276142c..1bf6a0ba4 100644
--- a/include/boost/random/detail/generator_bits.hpp
+++ b/include/boost/random/detail/generator_bits.hpp
@@ -14,7 +14,7 @@
 #ifndef BOOST_RANDOM_DETAIL_GENERATOR_BITS_HPP
 #define BOOST_RANDOM_DETAIL_GENERATOR_BITS_HPP
 
-#include <boost/limits.hpp>
+#include <limits>
 
 namespace boost {
 namespace random {
@@ -24,7 +24,7 @@ namespace detail {
 // compatibility.
 template<class URNG>
 struct generator_bits {
-    static std::size_t value() {
+    static int value() {
         return std::numeric_limits<typename URNG::result_type>::digits;
     }
 };
diff --git a/include/boost/random/detail/gray_coded_qrng.hpp b/include/boost/random/detail/gray_coded_qrng.hpp
index 1c0ccbf39..fdd42c367 100644
--- a/include/boost/random/detail/gray_coded_qrng.hpp
+++ b/include/boost/random/detail/gray_coded_qrng.hpp
@@ -13,6 +13,7 @@
 
 #include <boost/core/bit.hpp> // lsb
 #include <boost/throw_exception.hpp>
+#include <limits>
 #include <stdexcept>
 
 #include <functional> // bit_xor
diff --git a/include/boost/random/detail/int_float_pair.hpp b/include/boost/random/detail/int_float_pair.hpp
index 7ec2e2612..4f1f5105e 100644
--- a/include/boost/random/detail/int_float_pair.hpp
+++ b/include/boost/random/detail/int_float_pair.hpp
@@ -15,6 +15,7 @@
 #ifndef BOOST_RANDOM_DETAIL_INT_FLOAT_PAIR_HPP
 #define BOOST_RANDOM_DETAIL_INT_FLOAT_PAIR_HPP
 
+#include <limits>
 #include <utility>
 #include <boost/integer.hpp>
 #include <boost/integer/integer_mask.hpp>
diff --git a/include/boost/random/detail/integer_log2.hpp b/include/boost/random/detail/integer_log2.hpp
index 2e49f281f..dfb8ae131 100644
--- a/include/boost/random/detail/integer_log2.hpp
+++ b/include/boost/random/detail/integer_log2.hpp
@@ -14,8 +14,8 @@
 #ifndef BOOST_RANDOM_DETAIL_INTEGER_LOG2_HPP
 #define BOOST_RANDOM_DETAIL_INTEGER_LOG2_HPP
 
+#include <limits>
 #include <boost/config.hpp>
-#include <boost/limits.hpp>
 #include <boost/integer/integer_log2.hpp>
 
 namespace boost {
@@ -72,7 +72,7 @@ BOOST_RANDOM_DETAIL_CONSTEXPR int integer_log2(T t)
 {
     return integer_log2_impl<
         ::boost::detail::max_pow2_less<
-            ::std::numeric_limits<T>::digits, 4
+            std::numeric_limits<T>::digits, 4
         >::value
     >::apply(t, 0);
 }
diff --git a/include/boost/random/detail/large_arithmetic.hpp b/include/boost/random/detail/large_arithmetic.hpp
index 66f6b4e61..cfdc280b0 100644
--- a/include/boost/random/detail/large_arithmetic.hpp
+++ b/include/boost/random/detail/large_arithmetic.hpp
@@ -13,9 +13,9 @@
 #ifndef BOOST_RANDOM_DETAIL_LARGE_ARITHMETIC_HPP
 #define BOOST_RANDOM_DETAIL_LARGE_ARITHMETIC_HPP
 
-#include <boost/cstdint.hpp>
+#include <cstdint>
+#include <limits>
 #include <boost/integer.hpp>
-#include <boost/limits.hpp>
 #include <boost/random/detail/integer_log2.hpp>
 
 #include <boost/random/detail/disable_warnings.hpp>
@@ -25,18 +25,18 @@ namespace random {
 namespace detail {
 
 struct div_t {
-    boost::uintmax_t quotient;
-    boost::uintmax_t remainder;
+    std::uintmax_t quotient;
+    std::uintmax_t remainder;
 };
 
-inline div_t muldivmod(boost::uintmax_t a, boost::uintmax_t b, boost::uintmax_t m)
+inline div_t muldivmod(std::uintmax_t a, std::uintmax_t b, std::uintmax_t m)
 {
     const int bits =
-        ::std::numeric_limits< ::boost::uintmax_t>::digits / 2;
-    const ::boost::uintmax_t mask = (::boost::uintmax_t(1) << bits) - 1;
+        std::numeric_limits< std::uintmax_t>::digits / 2;
+    const std::uintmax_t mask = (std::uintmax_t(1) << bits) - 1;
     typedef ::boost::uint_t<bits>::fast digit_t;
 
-    int shift = std::numeric_limits< ::boost::uintmax_t>::digits - 1
+    int shift = std::numeric_limits< std::uintmax_t>::digits - 1
         - detail::integer_log2(m);
 
     a <<= shift;
@@ -51,7 +51,7 @@ inline div_t muldivmod(boost::uintmax_t a, boost::uintmax_t b, boost::uintmax_t
     for(int i = 0; i < 2; ++i) {
         digit_t carry = 0;
         for(int j = 0; j < 2; ++j) {
-            ::boost::uint64_t temp = ::boost::uintmax_t(a_[i]) * b_[j] +
+            std::uint64_t temp = std::uintmax_t(a_[i]) * b_[j] +
                 carry + product[i + j];
             product[i + j] = digit_t(temp & mask);
             carry = digit_t(temp >> bits);
@@ -65,23 +65,23 @@ inline div_t muldivmod(boost::uintmax_t a, boost::uintmax_t b, boost::uintmax_t
 
     if(m == 0) {
         div_t result = {
-            ((::boost::uintmax_t(product[3]) << bits) | product[2]),
-            ((::boost::uintmax_t(product[1]) << bits) | product[0]) >> shift,
+            ((std::uintmax_t(product[3]) << bits) | product[2]),
+            ((std::uintmax_t(product[1]) << bits) | product[0]) >> shift,
         };
         return result;
     }
 
     // divide product / m
     for(int i = 3; i >= 2; --i) {
-        ::boost::uintmax_t temp =
-            ::boost::uintmax_t(product[i]) << bits | product[i - 1];
+        std::uintmax_t temp =
+            std::uintmax_t(product[i]) << bits | product[i - 1];
 
         digit_t q = digit_t((product[i] == m_[1]) ? mask : temp / m_[1]);
 
-        ::boost::uintmax_t rem =
-            ((temp - ::boost::uintmax_t(q) * m_[1]) << bits) + product[i - 2];
+        std::uintmax_t rem =
+            ((temp - std::uintmax_t(q) * m_[1]) << bits) + product[i - 2];
 
-        ::boost::uintmax_t diff = m_[0] * ::boost::uintmax_t(q);
+        std::uintmax_t diff = m_[0] * std::uintmax_t(q);
 
         int error = 0;
         if(diff > rem) {
@@ -101,16 +101,16 @@ inline div_t muldivmod(boost::uintmax_t a, boost::uintmax_t b, boost::uintmax_t
     }
 
     div_t result = {
-        ((::boost::uintmax_t(quotient[1]) << bits) | quotient[0]),
-        ((::boost::uintmax_t(product[1]) << bits) | product[0]) >> shift,
+        ((std::uintmax_t(quotient[1]) << bits) | quotient[0]),
+        ((std::uintmax_t(product[1]) << bits) | product[0]) >> shift,
     };
     return result;
 }
 
-inline boost::uintmax_t muldiv(boost::uintmax_t a, boost::uintmax_t b, boost::uintmax_t m)
+inline std::uintmax_t muldiv(std::uintmax_t a, std::uintmax_t b, std::uintmax_t m)
 { return detail::muldivmod(a, b, m).quotient; }
 
-inline boost::uintmax_t mulmod(boost::uintmax_t a, boost::uintmax_t b, boost::uintmax_t m)
+inline std::uintmax_t mulmod(std::uintmax_t a, std::uintmax_t b, std::uintmax_t m)
 { return detail::muldivmod(a, b, m).remainder; }
 
 } // namespace detail
diff --git a/include/boost/random/detail/polynomial.hpp b/include/boost/random/detail/polynomial.hpp
index a8c4b269f..edd87986f 100644
--- a/include/boost/random/detail/polynomial.hpp
+++ b/include/boost/random/detail/polynomial.hpp
@@ -13,12 +13,12 @@
 #ifndef BOOST_RANDOM_DETAIL_POLYNOMIAL_HPP
 #define BOOST_RANDOM_DETAIL_POLYNOMIAL_HPP
 
+#include <cstdint>
 #include <cstddef>
 #include <limits>
 #include <vector>
 #include <algorithm>
 #include <boost/assert.hpp>
-#include <boost/cstdint.hpp>
 
 namespace boost {
 namespace random {
@@ -246,7 +246,7 @@ class polynomial_ops {
     // base should have the same number of bits as mod
     // base, and mod should both be able to hold a power
     // of 2 >= mod_bits.  out needs to be twice as large.
-    static void mod_pow_x(boost::uintmax_t exponent, const digit_t * mod, std::size_t mod_bits, digit_t * out)
+    static void mod_pow_x(std::uintmax_t exponent, const digit_t * mod, std::size_t mod_bits, digit_t * out)
     {
         const std::size_t bits = std::numeric_limits<digit_t>::digits;
         const std::size_t n = (mod_bits + bits - 1) / bits;
@@ -256,8 +256,8 @@ class polynomial_ops {
             std::fill_n(out + 1, n - 1, digit_t(0));
             return;
         }
-        boost::uintmax_t i = std::numeric_limits<boost::uintmax_t>::digits - 1;
-        while(((boost::uintmax_t(1) << i) & exponent) == 0) {
+        std::uintmax_t i = std::numeric_limits<std::uintmax_t>::digits - 1;
+        while(((std::uintmax_t(1) << i) & exponent) == 0) {
             --i;
         }
         out[0] = 2;
@@ -266,7 +266,7 @@ class polynomial_ops {
         while(i--) {
             sqr(out, n);
             m(out, 2 * mod_bits - 1);
-            if((boost::uintmax_t(1) << i) & exponent) {
+            if((std::uintmax_t(1) << i) & exponent) {
                 shift_left(out, n, 1);
                 if(out[highbit / bits] & (digit_t(1) << highbit%bits))
                     add(n, out, mod, out);
@@ -284,7 +284,12 @@ class polynomial
     public:
         reference(digit_t &value, int idx)
             : _value(value), _idx(idx) {}
-        operator bool() const { return (_value & (digit_t(1) << _idx)) != 0; }
+        reference(const reference& other) = default;
+        reference(reference&& other) = default;
+        reference &operator=(const reference &other)
+        {
+            return *this = static_cast<bool>(other);
+        }
         reference& operator=(bool b)
         {
             if(b) {
@@ -294,16 +299,14 @@ class polynomial
             }
             return *this;
         }
+        operator bool() const { return (_value & (digit_t(1) << _idx)) != 0; }
+
+
         reference &operator^=(bool b)
         {
             _value ^= (digit_t(b) << _idx);
             return *this;
         }
-
-        reference &operator=(const reference &other)
-        {
-            return *this = static_cast<bool>(other);
-        }
     private:
         digit_t &_value;
         int _idx;
@@ -337,9 +340,9 @@ class polynomial
         _size = n;
     }
     friend polynomial operator*(const polynomial &lhs, const polynomial &rhs);
-    friend polynomial mod_pow_x(boost::uintmax_t exponent, polynomial mod);
+    friend polynomial mod_pow_x(std::uintmax_t exponent, polynomial mod);
 private:
-    std::vector<polynomial_ops::digit_t> _storage;
+    std::vector<digit_t> _storage;
     std::size_t _size;
     void ensure_bit(std::size_t i)
     {
@@ -365,7 +368,7 @@ inline polynomial operator*(const polynomial &lhs, const polynomial &rhs)
     return result;
 }
 
-inline polynomial mod_pow_x(boost::uintmax_t exponent, polynomial mod)
+inline polynomial mod_pow_x(std::uintmax_t exponent, polynomial mod)
 {
     polynomial result;
     mod.normalize();
diff --git a/include/boost/random/detail/qrng_base.hpp b/include/boost/random/detail/qrng_base.hpp
index 5eeacfb78..ffb03d4fb 100644
--- a/include/boost/random/detail/qrng_base.hpp
+++ b/include/boost/random/detail/qrng_base.hpp
@@ -9,6 +9,7 @@
 #ifndef BOOST_RANDOM_DETAIL_QRNG_BASE_HPP
 #define BOOST_RANDOM_DETAIL_QRNG_BASE_HPP
 
+#include <cstdint>
 #include <stdexcept>
 #include <vector>
 #include <limits>
@@ -17,7 +18,6 @@
 #include <ostream>
 #include <sstream>
 
-#include <boost/cstdint.hpp>
 #include <boost/random/detail/operators.hpp>
 
 #include <boost/throw_exception.hpp>
@@ -100,7 +100,7 @@ class qrng_base
   //!X::operator() invocations were executed.
   //!
   //!Throws: range_error.
-  void discard(boost::uintmax_t z)
+  void discard(std::uintmax_t z)
   {
     const std::size_t dimension_value = dimension();
 
@@ -108,7 +108,7 @@ class qrng_base
     // statements. In fact, gcc does this even at -O1, so don't
     // be tempted to "optimize" % via subtraction and multiplication.
 
-    boost::uintmax_t vec_n = z / dimension_value;
+    std::uintmax_t vec_n = z / dimension_value;
     std::size_t carry = curr_elem + (z % dimension_value);
 
     vec_n += carry / dimension_value;
@@ -119,7 +119,7 @@ class qrng_base
     const bool corr = (!carry) & static_cast<bool>(vec_n);
 
     // Discards vec_n (with correction) consecutive s-dimensional vectors
-    discard_vector(vec_n - static_cast<boost::uintmax_t>(corr));
+    discard_vector(vec_n - static_cast<std::uintmax_t>(corr));
 
 #ifdef BOOST_MSVC
 #pragma warning(push)
@@ -149,7 +149,7 @@ class qrng_base
   {
     std::size_t dim;
     size_type seed;
-    boost::uintmax_t z;
+    std::uintmax_t z;
     if (is >> dim >> std::ws >> seed >> std::ws >> z) // initialize iff success!
     {
       // Check seed sign before resizing the lattice and/or recomputing state
@@ -234,9 +234,9 @@ class qrng_base
 
   // Discards z consecutive s-dimensional vectors,
   // and preserves the position of the element-to-read
-  void discard_vector(boost::uintmax_t z)
+  void discard_vector(std::uintmax_t z)
   {
-    const boost::uintmax_t max_z = (std::numeric_limits<size_type>::max)() - seq_count;
+    const std::uintmax_t max_z = (std::numeric_limits<size_type>::max)() - seq_count;
 
     // Don't allow seq_count + z overflows here
     if (max_z < z)
diff --git a/include/boost/random/detail/seed_impl.hpp b/include/boost/random/detail/seed_impl.hpp
index 5e79582a2..e4c2ba43d 100644
--- a/include/boost/random/detail/seed_impl.hpp
+++ b/include/boost/random/detail/seed_impl.hpp
@@ -13,8 +13,9 @@
 #ifndef BOOST_RANDOM_DETAIL_SEED_IMPL_HPP
 #define BOOST_RANDOM_DETAIL_SEED_IMPL_HPP
 
+#include <cstdint>
+#include <limits>
 #include <stdexcept>
-#include <boost/cstdint.hpp>
 #include <boost/throw_exception.hpp>
 #include <boost/config/no_tr1/cmath.hpp>
 #include <boost/integer/integer_mask.hpp>
@@ -42,7 +43,7 @@ struct seed_type
 {
     typedef typename boost::conditional<boost::is_integral<T>::value,
         T,
-        boost::uint32_t
+        std::uint32_t
     >::type type;
 };
 
@@ -88,7 +89,7 @@ void generate_from_real(Engine& eng, Iter begin, Iter end)
     typedef typename Engine::result_type RealType;
     const int Bits = detail::generator_bits<Engine>::value();
     int remaining_bits = 0;
-    boost::uint_least32_t saved_bits = 0;
+    std::uint_least32_t saved_bits = 0;
     RealType multiplier = pow2<RealType>( Bits);
     RealType mult32 = RealType(4294967296.0); // 2^32
     while(true) {
@@ -97,16 +98,16 @@ void generate_from_real(Engine& eng, Iter begin, Iter end)
         // Make sure the compiler can optimize this out
         // if it isn't possible.
         if(Bits < 32 && available_bits < 32 - remaining_bits) {
-            saved_bits |= boost::uint_least32_t(val) << remaining_bits;
+            saved_bits |= std::uint_least32_t(val) << remaining_bits;
             remaining_bits += Bits;
         } else {
             // If Bits < 32, then remaining_bits != 0, since
             // if remaining_bits == 0, available_bits < 32 - 0,
             // and we won't get here to begin with.
             if(Bits < 32 || remaining_bits != 0) {
-                boost::uint_least32_t divisor =
-                    (boost::uint_least32_t(1) << (32 - remaining_bits));
-                boost::uint_least32_t extra_bits = boost::uint_least32_t(fmod(val, mult32)) & (divisor - 1);
+                std::uint_least32_t divisor =
+                    (std::uint_least32_t(1) << (32 - remaining_bits));
+                std::uint_least32_t extra_bits = std::uint_least32_t(fmod(val, mult32)) & (divisor - 1);
                 val = val / divisor;
                 *begin++ = saved_bits | (extra_bits << remaining_bits);
                 if(begin == end) return;
@@ -116,14 +117,14 @@ void generate_from_real(Engine& eng, Iter begin, Iter end)
             // If Bits < 32 we should never enter this loop
             if(Bits >= 32) {
                 for(; available_bits >= 32; available_bits -= 32) {
-                    boost::uint_least32_t word = boost::uint_least32_t(fmod(val, mult32));
+                    std::uint_least32_t word = std::uint_least32_t(fmod(val, mult32));
                     val /= mult32;
                     *begin++ = word;
                     if(begin == end) return;
                 }
             }
             remaining_bits = available_bits;
-            saved_bits = static_cast<boost::uint_least32_t>(val);
+            saved_bits = static_cast<std::uint_least32_t>(val);
         }
     }
 }
@@ -134,7 +135,7 @@ void generate_from_int(Engine& eng, Iter begin, Iter end)
     typedef typename Engine::result_type IntType;
     typedef typename boost::random::traits::make_unsigned<IntType>::type unsigned_type;
     int remaining_bits = 0;
-    boost::uint_least32_t saved_bits = 0;
+    std::uint_least32_t saved_bits = 0;
     unsigned_type range = boost::random::detail::subtract<IntType>()((eng.max)(), (eng.min)());
 
     int bits =
@@ -162,11 +163,11 @@ void generate_from_int(Engine& eng, Iter begin, Iter end)
         val &= mask;
         int available_bits = bits;
         if(available_bits == 32) {
-            *begin++ = static_cast<boost::uint_least32_t>(val) & 0xFFFFFFFFu;
+            *begin++ = static_cast<std::uint_least32_t>(val) & 0xFFFFFFFFu;
             if(begin == end) return;
         } else if(available_bits % 32 == 0) {
             for(int i = 0; i < available_bits / 32; ++i) {
-                boost::uint_least32_t word = boost::uint_least32_t(val) & 0xFFFFFFFFu;
+                std::uint_least32_t word = std::uint_least32_t(val) & 0xFFFFFFFFu;
                 int suppress_warning = (bits >= 32);
                 BOOST_ASSERT(suppress_warning == 1);
                 val >>= (32 * suppress_warning);
@@ -174,11 +175,11 @@ void generate_from_int(Engine& eng, Iter begin, Iter end)
                 if(begin == end) return;
             }
         } else if(bits < 32 && available_bits < 32 - remaining_bits) {
-            saved_bits |= boost::uint_least32_t(val) << remaining_bits;
+            saved_bits |= std::uint_least32_t(val) << remaining_bits;
             remaining_bits += bits;
         } else {
             if(bits < 32 || remaining_bits != 0) {
-                boost::uint_least32_t extra_bits = boost::uint_least32_t(val) & ((boost::uint_least32_t(1) << (32 - remaining_bits)) - 1);
+                std::uint_least32_t extra_bits = std::uint_least32_t(val) & ((std::uint_least32_t(1) << (32 - remaining_bits)) - 1);
                 val >>= 32 - remaining_bits;
                 *begin++ = saved_bits | (extra_bits << remaining_bits);
                 if(begin == end) return;
@@ -187,7 +188,7 @@ void generate_from_int(Engine& eng, Iter begin, Iter end)
             }
             if(bits >= 32) {
                 for(; available_bits >= 32; available_bits -= 32) {
-                    boost::uint_least32_t word = boost::uint_least32_t(val) & 0xFFFFFFFFu;
+                    std::uint_least32_t word = std::uint_least32_t(val) & 0xFFFFFFFFu;
                     int suppress_warning = (bits >= 32);
                     BOOST_ASSERT(suppress_warning == 1);
                     val >>= (32 * suppress_warning);
@@ -196,7 +197,7 @@ void generate_from_int(Engine& eng, Iter begin, Iter end)
                 }
             }
             remaining_bits = available_bits;
-            saved_bits = static_cast<boost::uint_least32_t>(val);
+            saved_bits = static_cast<std::uint_least32_t>(val);
         }
     }
 }
@@ -225,11 +226,11 @@ template<class IntType, IntType m, class SeedSeq>
 IntType seed_one_int(SeedSeq& seq)
 {
     static const int log = ::boost::conditional<(m == 0),
-        ::boost::integral_constant<int, (::std::numeric_limits<IntType>::digits)>,
+        std::integral_constant<int, (std::numeric_limits<IntType>::digits)>,
         ::boost::static_log2<m> >::type::value;
     static const int k =
         (log + ((~(static_cast<IntType>(2) << (log - 1)) & m)? 32 : 31)) / 32;
-    ::boost::uint_least32_t array[log / 32 + 4];
+    std::uint_least32_t array[log / 32 + 4];
     seq.generate(&array[0], &array[0] + k + 3);
     IntType s = 0;
     for(int j = 0; j < k; ++j) {
@@ -244,14 +245,14 @@ template<class IntType, IntType m, class Iter>
 IntType get_one_int(Iter& first, Iter last)
 {
     static const int log = ::boost::conditional<(m == 0),
-        ::boost::integral_constant<int, (::std::numeric_limits<IntType>::digits)>,
+        std::integral_constant<int, (std::numeric_limits<IntType>::digits)>,
         ::boost::static_log2<m> >::type::value;
     static const int k =
         (log + ((~(static_cast<IntType>(2) << (log - 1)) & m)? 32 : 31)) / 32;
     IntType s = 0;
     for(int j = 0; j < k; ++j) {
         if(first == last) {
-            boost::throw_exception(::std::invalid_argument("Not enough elements in call to seed."));
+            boost::throw_exception(std::invalid_argument("Not enough elements in call to seed."));
         }
         IntType digit = const_mod<IntType, m>::apply(IntType(*first++));
         IntType mult = IntType(1) << 32*j;
@@ -264,7 +265,7 @@ IntType get_one_int(Iter& first, Iter last)
 template<int w, std::size_t n, class SeedSeq, class UIntType>
 void seed_array_int_impl(SeedSeq& seq, UIntType (&x)[n])
 {
-    boost::uint_least32_t storage[((w+31)/32) * n];
+    std::uint_least32_t storage[((w+31)/32) * n];
     seq.generate(&storage[0], &storage[0] + ((w+31)/32) * n);
     for(std::size_t j = 0; j < n; j++) {
         UIntType val = 0;
@@ -331,9 +332,9 @@ inline void fill_array_int(Iter& first, Iter last, IntType (&x)[n])
 }
 
 template<int w, std::size_t n, class RealType>
-void seed_array_real_impl(const boost::uint_least32_t* storage, RealType (&x)[n])
+void seed_array_real_impl(const std::uint_least32_t* storage, RealType (&x)[n])
 {
-    boost::uint_least32_t mask = ~((~boost::uint_least32_t(0)) << (w%32));
+    std::uint_least32_t mask = ~((~std::uint_least32_t(0)) << (w%32));
     RealType two32 = 4294967296.0;
     const RealType divisor = RealType(1)/detail::pow2<RealType>(w);
     unsigned int j;
@@ -356,8 +357,7 @@ void seed_array_real_impl(const boost::uint_least32_t* storage, RealType (&x)[n]
 template<int w, std::size_t n, class SeedSeq, class RealType>
 void seed_array_real(SeedSeq& seq, RealType (&x)[n])
 {
-    using std::pow;
-    boost::uint_least32_t storage[((w+31)/32) * n];
+    std::uint_least32_t storage[((w+31)/32) * n];
     seq.generate(&storage[0], &storage[0] + ((w+31)/32) * n);
     seed_array_real_impl<w>(storage, x);
 }
@@ -365,7 +365,7 @@ void seed_array_real(SeedSeq& seq, RealType (&x)[n])
 template<int w, std::size_t n, class Iter, class RealType>
 void fill_array_real(Iter& first, Iter last, RealType (&x)[n])
 {
-    boost::uint_least32_t mask = ~((~boost::uint_least32_t(0)) << (w%32));
+    std::uint_least32_t mask = ~((~std::uint_least32_t(0)) << (w%32));
     RealType two32 = 4294967296.0;
     const RealType divisor = RealType(1)/detail::pow2<RealType>(w);
     unsigned int j;
diff --git a/include/boost/random/detail/signed_unsigned_tools.hpp b/include/boost/random/detail/signed_unsigned_tools.hpp
index 1979908a3..fd09030d2 100644
--- a/include/boost/random/detail/signed_unsigned_tools.hpp
+++ b/include/boost/random/detail/signed_unsigned_tools.hpp
@@ -11,7 +11,7 @@
 #ifndef BOOST_RANDOM_DETAIL_SIGNED_UNSIGNED_TOOLS
 #define BOOST_RANDOM_DETAIL_SIGNED_UNSIGNED_TOOLS
 
-#include <boost/limits.hpp>
+#include <limits>
 #include <boost/config.hpp>
 #include <boost/random/traits.hpp>
 
diff --git a/include/boost/random/detail/uniform_int_float.hpp b/include/boost/random/detail/uniform_int_float.hpp
index 393c455bc..e73031396 100644
--- a/include/boost/random/detail/uniform_int_float.hpp
+++ b/include/boost/random/detail/uniform_int_float.hpp
@@ -15,7 +15,8 @@
 #ifndef BOOST_RANDOM_DETAIL_UNIFORM_INT_FLOAT_HPP
 #define BOOST_RANDOM_DETAIL_UNIFORM_INT_FLOAT_HPP
 
-#include <boost/limits.hpp>
+#include <cstdint>
+#include <limits>
 #include <boost/config.hpp>
 #include <boost/integer.hpp>
 #include <boost/random/detail/config.hpp>
@@ -35,9 +36,9 @@ class uniform_int_float
     typedef typename base_type::result_type base_result;
 
     typedef typename boost::uint_t<
-        (std::numeric_limits<boost::uintmax_t>::digits <
+        (std::numeric_limits<std::uintmax_t>::digits <
             std::numeric_limits<base_result>::digits)?
-        std::numeric_limits<boost::uintmax_t>::digits :
+        std::numeric_limits<std::uintmax_t>::digits :
         std::numeric_limits<base_result>::digits
     >::fast result_type;
 
diff --git a/include/boost/random/discard_block.hpp b/include/boost/random/discard_block.hpp
index b9b09ab8f..0258bb9b7 100644
--- a/include/boost/random/discard_block.hpp
+++ b/include/boost/random/discard_block.hpp
@@ -17,10 +17,9 @@
 #ifndef BOOST_RANDOM_DISCARD_BLOCK_HPP
 #define BOOST_RANDOM_DISCARD_BLOCK_HPP
 
+#include <cstdint>
 #include <iostream>
 #include <boost/config.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/limits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/random/detail/config.hpp>
 #include <boost/random/detail/seed.hpp>
@@ -121,9 +120,9 @@ class discard_block_engine
         return _rng();
     }
 
-    void discard(boost::uintmax_t z)
+    void discard(std::uintmax_t z)
     {
-        for(boost::uintmax_t j = 0; j < z; ++j) {
+        for(std::uintmax_t j = 0; j < z; ++j) {
             (*this)();
         }
     }
diff --git a/include/boost/random/discrete_distribution.hpp b/include/boost/random/discrete_distribution.hpp
index 877cbf2bd..847f735d4 100644
--- a/include/boost/random/discrete_distribution.hpp
+++ b/include/boost/random/discrete_distribution.hpp
@@ -456,7 +456,7 @@ class discrete_distribution {
             {
                 sum += *iter;
                 if(sum > val) {
-                    return result;
+                    return static_cast<IntType>(result);
                 }
             }
             // This shouldn't be reachable, but round-off error
@@ -501,7 +501,7 @@ class discrete_distribution {
         {
             WeightType val = iter->first;
             result[i] += val;
-            result[static_cast<std::size_t>(iter->second)] += _impl.get_weight(i) - val;
+            result[static_cast<std::size_t>(iter->second)] += _impl.get_weight(static_cast<IntType>(i)) - val;
         }
         impl_type::normalize(result);
         return(result);
diff --git a/include/boost/random/exponential_distribution.hpp b/include/boost/random/exponential_distribution.hpp
index b4b95c547..e3dbb12e2 100644
--- a/include/boost/random/exponential_distribution.hpp
+++ b/include/boost/random/exponential_distribution.hpp
@@ -20,8 +20,8 @@
 
 #include <boost/config/no_tr1/cmath.hpp>
 #include <iosfwd>
+#include <limits>
 #include <boost/assert.hpp>
-#include <boost/limits.hpp>
 #include <boost/random/detail/config.hpp>
 #include <boost/random/detail/operators.hpp>
 #include <boost/random/detail/int_float_pair.hpp>
diff --git a/include/boost/random/extreme_value_distribution.hpp b/include/boost/random/extreme_value_distribution.hpp
index 419c3da65..f3934b00a 100644
--- a/include/boost/random/extreme_value_distribution.hpp
+++ b/include/boost/random/extreme_value_distribution.hpp
@@ -16,8 +16,8 @@
 #include <boost/config/no_tr1/cmath.hpp>
 #include <iosfwd>
 #include <istream>
+#include <limits>
 #include <boost/config.hpp>
-#include <boost/limits.hpp>
 #include <boost/random/detail/operators.hpp>
 #include <boost/random/uniform_01.hpp>
 
diff --git a/include/boost/random/faure.hpp b/include/boost/random/faure.hpp
index 4301c301b..a03029306 100644
--- a/include/boost/random/faure.hpp
+++ b/include/boost/random/faure.hpp
@@ -11,6 +11,7 @@
 
 #include <boost/random/detail/qrng_base.hpp>
 
+#include <cstdint>
 #include <cmath>
 #include <vector>
 #include <algorithm>
@@ -318,10 +319,10 @@ class faure_engine
     return base_t::operator()();
   }
 
-  /** @copydoc boost::random::niederreiter_base2_engine::discard(boost::uintmax_t)
+  /** @copydoc boost::random::niederreiter_base2_engine::discard(std::uintmax_t)
    * Throws: bad_alloc.
    */
-  void discard(boost::uintmax_t z)
+  void discard(std::uintmax_t z)
   {
     base_t::discard(z);
   }
@@ -358,7 +359,7 @@ class faure_engine
  *
  * However, it is possible to provide your own prime table to \faure_engine should the default one be insufficient.
  */
-typedef faure_engine<double, boost::uint_least64_t, default_faure_prime_table> faure;
+typedef faure_engine<double, std::uint_least64_t, default_faure_prime_table> faure;
 
 } // namespace random
 
diff --git a/include/boost/random/fisher_f_distribution.hpp b/include/boost/random/fisher_f_distribution.hpp
index cdf14da8f..d96c69dd7 100644
--- a/include/boost/random/fisher_f_distribution.hpp
+++ b/include/boost/random/fisher_f_distribution.hpp
@@ -15,8 +15,8 @@
 
 #include <iosfwd>
 #include <istream>
+#include <limits>
 #include <boost/config.hpp>
-#include <boost/limits.hpp>
 #include <boost/random/detail/operators.hpp>
 #include <boost/random/chi_squared_distribution.hpp>
 
diff --git a/include/boost/random/gamma_distribution.hpp b/include/boost/random/gamma_distribution.hpp
index 34d0452aa..d0bbd94ac 100644
--- a/include/boost/random/gamma_distribution.hpp
+++ b/include/boost/random/gamma_distribution.hpp
@@ -18,8 +18,8 @@
 #include <boost/config/no_tr1/cmath.hpp>
 #include <istream>
 #include <iosfwd>
+#include <limits>
 #include <boost/assert.hpp>
-#include <boost/limits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/random/detail/config.hpp>
 #include <boost/random/exponential_distribution.hpp>
diff --git a/include/boost/random/generalized_inverse_gaussian_distribution.hpp b/include/boost/random/generalized_inverse_gaussian_distribution.hpp
index ce2154c8c..e6c44dd3e 100644
--- a/include/boost/random/generalized_inverse_gaussian_distribution.hpp
+++ b/include/boost/random/generalized_inverse_gaussian_distribution.hpp
@@ -18,7 +18,6 @@
 #include <iosfwd>
 #include <limits>
 #include <boost/assert.hpp>
-#include <boost/limits.hpp>
 #include <boost/random/detail/config.hpp>
 #include <boost/random/detail/operators.hpp>
 #include <boost/random/uniform_01.hpp>
diff --git a/include/boost/random/generate_canonical.hpp b/include/boost/random/generate_canonical.hpp
index 5f45b4e57..5d59135d9 100644
--- a/include/boost/random/generate_canonical.hpp
+++ b/include/boost/random/generate_canonical.hpp
@@ -15,9 +15,9 @@
 #define BOOST_RANDOM_GENERATE_CANONICAL_HPP
 
 #include <algorithm>
+#include <limits>
 #include <boost/assert.hpp>
 #include <boost/config/no_tr1/cmath.hpp>
-#include <boost/limits.hpp>
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/random/detail/signed_unsigned_tools.hpp>
 #include <boost/random/detail/generator_bits.hpp>
diff --git a/include/boost/random/geometric_distribution.hpp b/include/boost/random/geometric_distribution.hpp
index 90374cff7..4ce8b6e22 100644
--- a/include/boost/random/geometric_distribution.hpp
+++ b/include/boost/random/geometric_distribution.hpp
@@ -20,6 +20,7 @@
 #include <boost/config/no_tr1/cmath.hpp>          // std::log
 #include <iosfwd>
 #include <ios>
+#include <limits>
 #include <boost/assert.hpp>
 #include <boost/random/detail/config.hpp>
 #include <boost/random/detail/operators.hpp>
diff --git a/include/boost/random/independent_bits.hpp b/include/boost/random/independent_bits.hpp
index 72a8ed71a..0a1c10a30 100644
--- a/include/boost/random/independent_bits.hpp
+++ b/include/boost/random/independent_bits.hpp
@@ -14,12 +14,12 @@
 #ifndef BOOST_RANDOM_INDEPENDENT_BITS_HPP
 #define BOOST_RANDOM_INDEPENDENT_BITS_HPP
 
+#include <cstdint>
 #include <istream>
 #include <iosfwd>
+#include <limits>
 #include <boost/assert.hpp>
-#include <boost/limits.hpp>
 #include <boost/config.hpp>
-#include <boost/cstdint.hpp>
 #include <boost/integer/integer_mask.hpp>
 #include <boost/random/traits.hpp>
 #include <boost/random/detail/config.hpp>
@@ -194,9 +194,9 @@ class independent_bits_engine
     { detail::generate_from_int(*this, first, last); }
 
     /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z)
+    void discard(std::uintmax_t z)
     {
-        for(boost::uintmax_t i = 0; i < z; ++i) {
+        for(std::uintmax_t i = 0; i < z; ++i) {
             (*this)();
         }
     }
diff --git a/include/boost/random/inverse_gaussian_distribution.hpp b/include/boost/random/inverse_gaussian_distribution.hpp
index 7bb0f1ca3..f9b30f885 100644
--- a/include/boost/random/inverse_gaussian_distribution.hpp
+++ b/include/boost/random/inverse_gaussian_distribution.hpp
@@ -18,7 +18,6 @@
 #include <iosfwd>
 #include <limits>
 #include <boost/assert.hpp>
-#include <boost/limits.hpp>
 #include <boost/random/detail/config.hpp>
 #include <boost/random/detail/operators.hpp>
 #include <boost/random/uniform_01.hpp>
diff --git a/include/boost/random/inversive_congruential.hpp b/include/boost/random/inversive_congruential.hpp
index 493e51c94..d3728aa32 100644
--- a/include/boost/random/inversive_congruential.hpp
+++ b/include/boost/random/inversive_congruential.hpp
@@ -16,11 +16,11 @@
 #ifndef BOOST_RANDOM_INVERSIVE_CONGRUENTIAL_HPP
 #define BOOST_RANDOM_INVERSIVE_CONGRUENTIAL_HPP
 
+#include <cstdint>
 #include <iosfwd>
 #include <stdexcept>
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
-#include <boost/cstdint.hpp>
 #include <boost/random/detail/config.hpp>
 #include <boost/random/detail/const_mod.hpp>
 #include <boost/random/detail/seed.hpp>
@@ -171,9 +171,9 @@ class inversive_congruential_engine
     { detail::generate_from_int(*this, first, last); }
 
     /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z)
+    void discard(std::uintmax_t z)
     {
-        for(boost::uintmax_t j = 0; j < z; ++j) {
+        for(std::uintmax_t j = 0; j < z; ++j) {
             (*this)();
         }
     }
diff --git a/include/boost/random/lagged_fibonacci.hpp b/include/boost/random/lagged_fibonacci.hpp
index 0c93bae4a..3b8da0375 100644
--- a/include/boost/random/lagged_fibonacci.hpp
+++ b/include/boost/random/lagged_fibonacci.hpp
@@ -17,14 +17,13 @@
 #ifndef BOOST_RANDOM_LAGGED_FIBONACCI_HPP
 #define BOOST_RANDOM_LAGGED_FIBONACCI_HPP
 
+#include <cstdint>
 #include <istream>
 #include <iosfwd>
 #include <algorithm>     // std::max
 #include <iterator>
 #include <boost/config/no_tr1/cmath.hpp>         // std::pow
 #include <boost/config.hpp>
-#include <boost/limits.hpp>
-#include <boost/cstdint.hpp>
 #include <boost/integer/integer_mask.hpp>
 #include <boost/random/linear_congruential.hpp>
 #include <boost/random/uniform_01.hpp>
@@ -91,7 +90,7 @@ class lagged_fibonacci_engine
     BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(lagged_fibonacci_engine,
         UIntType, value)
     {
-        minstd_rand0 intgen(static_cast<boost::uint32_t>(value));
+        minstd_rand0 intgen(static_cast<std::uint32_t>(value));
         detail::generator_seed_seq<minstd_rand0> gen(intgen);
         seed(gen);
     }
@@ -131,9 +130,9 @@ class lagged_fibonacci_engine
     { detail::generate_from_int(*this, first, last); }
 
     /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z)
+    void discard(std::uintmax_t z)
     {
-        for(boost::uintmax_t j = 0; j < z; ++j) {
+        for(std::uintmax_t j = 0; j < z; ++j) {
             (*this)();
         }
     }
@@ -154,9 +153,9 @@ class lagged_fibonacci_engine
      */
     BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, lagged_fibonacci_engine, f)
     {
-        is >> f.i >> std::ws;
+        is >> f.i;
         for(unsigned int j = 0; j < f.long_lag; ++j)
-            is >> f.x[j] >> std::ws;
+            is >> std::ws >> f.x[j];
         return is;
     }
 
@@ -266,7 +265,7 @@ class lagged_fibonacci_01_engine
     BOOST_STATIC_CONSTANT(unsigned int, long_lag = p);
     BOOST_STATIC_CONSTANT(unsigned int, short_lag = q);
 
-    BOOST_STATIC_CONSTANT(boost::uint32_t, default_seed = 331u);
+    BOOST_STATIC_CONSTANT(std::uint32_t, default_seed = 331u);
 
     /** Constructs a @c lagged_fibonacci_01 generator and calls @c seed(). */
     lagged_fibonacci_01_engine() { seed(); }
@@ -291,7 +290,7 @@ class lagged_fibonacci_01_engine
      * seeds will be equivalent to some seed within this range. See
      * \linear_congruential_engine for details.
      */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(lagged_fibonacci_01_engine, boost::uint32_t, value)
+    BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(lagged_fibonacci_01_engine, std::uint32_t, value)
     {
         minstd_rand0 intgen(value);
         detail::generator_seed_seq<minstd_rand0> gen(intgen);
@@ -339,9 +338,9 @@ class lagged_fibonacci_01_engine
     { return detail::generate_from_real(*this, first, last); }
 
     /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z)
+    void discard(std::uintmax_t z)
     {
-        for(boost::uintmax_t j = 0; j < z; ++j) {
+        for(std::uintmax_t j = 0; j < z; ++j) {
             (*this)();
         }
     }
@@ -412,7 +411,7 @@ const unsigned int lagged_fibonacci_01_engine<RealType, w, p, q>::short_lag;
 template<class RealType, int w, unsigned int p, unsigned int q>
 const int lagged_fibonacci_01_engine<RealType,w,p,q>::word_size;
 template<class RealType, int w, unsigned int p, unsigned int q>
-const boost::uint32_t lagged_fibonacci_01_engine<RealType,w,p,q>::default_seed;
+const std::uint32_t lagged_fibonacci_01_engine<RealType,w,p,q>::default_seed;
 #endif
 
 /// \cond show_private
@@ -447,7 +446,7 @@ class lagged_fibonacci_01 : public lagged_fibonacci_01_engine<RealType, w, p, q>
     typedef lagged_fibonacci_01_engine<RealType, w, p, q> base_type;
 public:
     lagged_fibonacci_01() {}
-    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(lagged_fibonacci_01, boost::uint32_t, val)
+    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(lagged_fibonacci_01, std::uint32_t, val)
     { this->seed(val); }
     BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(lagged_fibonacci_01, SeedSeq, seq)
     { this->seed(seq); }
diff --git a/include/boost/random/laplace_distribution.hpp b/include/boost/random/laplace_distribution.hpp
index ec176a59c..d01c8c471 100644
--- a/include/boost/random/laplace_distribution.hpp
+++ b/include/boost/random/laplace_distribution.hpp
@@ -16,6 +16,7 @@
 #include <cassert>
 #include <istream>
 #include <iosfwd>
+#include <limits>
 #include <boost/random/detail/operators.hpp>
 #include <boost/random/exponential_distribution.hpp>
 
diff --git a/include/boost/random/linear_congruential.hpp b/include/boost/random/linear_congruential.hpp
index 62b05ec00..3265b9b2d 100644
--- a/include/boost/random/linear_congruential.hpp
+++ b/include/boost/random/linear_congruential.hpp
@@ -16,12 +16,12 @@
 #ifndef BOOST_RANDOM_LINEAR_CONGRUENTIAL_HPP
 #define BOOST_RANDOM_LINEAR_CONGRUENTIAL_HPP
 
+#include <cstdint>
 #include <iostream>
+#include <limits>
 #include <stdexcept>
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/limits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_arithmetic.hpp>
 #include <boost/random/detail/config.hpp>
@@ -190,7 +190,7 @@ class linear_congruential_engine
     { detail::generate_from_int(*this, first, last); }
 
     /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z)
+    void discard(std::uintmax_t z)
     {
         typedef const_mod<IntType, m> mod_type;
         IntType b_inv = mod_type::invert(a-1);
@@ -204,7 +204,7 @@ class linear_congruential_engine
             // we're storing the intermediate result / b_gcd
             IntType a_zm1_over_gcd = 0;
             IntType a_km1_over_gcd = (a - 1) / b_gcd;
-            boost::uintmax_t exponent = z;
+            std::uintmax_t exponent = z;
             while(exponent != 0) {
                 if(exponent % 2 == 1) {
                     a_zm1_over_gcd =
@@ -349,7 +349,7 @@ typedef linear_congruential_engine<uint32_t, 48271, 0, 2147483647> minstd_rand;
 class rand48 
 {
 public:
-    typedef boost::uint32_t result_type;
+    typedef std::uint32_t result_type;
 
     BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
     /**
@@ -404,7 +404,7 @@ class rand48
     uint32_t operator()() { return static_cast<uint32_t>(lcf() >> 17); }
     
     /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z) { lcf.discard(z); }
+    void discard(std::uintmax_t z) { lcf.discard(z); }
   
     /** Fills a range with random values */
     template<class Iter>
@@ -449,7 +449,7 @@ class rand48
         0xB, uint64_t(1)<<48> lcf_t;
     lcf_t lcf;
 
-    static boost::uint64_t cnv(boost::uint32_t x)
+    static std::uint64_t cnv(std::uint32_t x)
     { return (static_cast<uint64_t>(x) << 16) | 0x330e; }
     /// \endcond
 };
diff --git a/include/boost/random/linear_feedback_shift.hpp b/include/boost/random/linear_feedback_shift.hpp
index a5c2ce7a2..347d0c78d 100644
--- a/include/boost/random/linear_feedback_shift.hpp
+++ b/include/boost/random/linear_feedback_shift.hpp
@@ -15,10 +15,10 @@
 #ifndef BOOST_RANDOM_LINEAR_FEEDBACK_SHIFT_HPP
 #define BOOST_RANDOM_LINEAR_FEEDBACK_SHIFT_HPP
 
+#include <cstdint>
 #include <iosfwd>
 #include <stdexcept>
 #include <boost/config.hpp>
-#include <boost/cstdint.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/integer/integer_mask.hpp>
 #include <boost/random/detail/config.hpp>
@@ -128,9 +128,9 @@ class linear_feedback_shift_engine
     { detail::generate_from_int(*this, first, last); }
 
     /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z)
+    void discard(std::uintmax_t z)
     {
-        for(boost::uintmax_t j = 0; j < z; ++j) {
+        for(std::uintmax_t j = 0; j < z; ++j) {
             (*this)();
         }
     }
diff --git a/include/boost/random/lognormal_distribution.hpp b/include/boost/random/lognormal_distribution.hpp
index 7ed1e13ab..a457d3540 100644
--- a/include/boost/random/lognormal_distribution.hpp
+++ b/include/boost/random/lognormal_distribution.hpp
@@ -21,7 +21,7 @@
 #include <cassert>
 #include <iosfwd>
 #include <istream>
-#include <boost/limits.hpp>
+#include <limits>
 #include <boost/random/detail/config.hpp>
 #include <boost/random/detail/operators.hpp>
 #include <boost/random/normal_distribution.hpp>
diff --git a/include/boost/random/mersenne_twister.hpp b/include/boost/random/mersenne_twister.hpp
index dfdc2d713..b51eb83af 100644
--- a/include/boost/random/mersenne_twister.hpp
+++ b/include/boost/random/mersenne_twister.hpp
@@ -18,16 +18,17 @@
 #ifndef BOOST_RANDOM_MERSENNE_TWISTER_HPP
 #define BOOST_RANDOM_MERSENNE_TWISTER_HPP
 
+#include <cstdint>
 #include <iosfwd>
 #include <istream>
 #include <stdexcept>
 #include <boost/config.hpp>
-#include <boost/cstdint.hpp>
 #include <boost/integer/integer_mask.hpp>
 #include <boost/random/detail/config.hpp>
 #include <boost/random/detail/ptr_helper.hpp>
 #include <boost/random/detail/seed.hpp>
 #include <boost/random/detail/seed_impl.hpp>
+#include <boost/random/detail/operators.hpp>
 #include <boost/random/detail/generator_seed_seq.hpp>
 #include <boost/random/detail/polynomial.hpp>
 
@@ -200,7 +201,7 @@ class mersenne_twister_engine
      * }
      * @endcode
      */
-    void discard(boost::uintmax_t z)
+    void discard(std::uintmax_t z)
     {
 #ifndef BOOST_RANDOM_MERSENNE_TWISTER_DISCARD_THRESHOLD
 #define BOOST_RANDOM_MERSENNE_TWISTER_DISCARD_THRESHOLD 10000000
@@ -208,7 +209,7 @@ class mersenne_twister_engine
         if(z > BOOST_RANDOM_MERSENNE_TWISTER_DISCARD_THRESHOLD) {
             discard_many(z);
         } else {
-            for(boost::uintmax_t j = 0; j < z; ++j) {
+            for(std::uintmax_t j = 0; j < z; ++j) {
                 (*this)();
             }
         }
@@ -216,26 +217,28 @@ class mersenne_twister_engine
 
 #ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
     /** Writes a mersenne_twister_engine to a @c std::ostream */
-    template<class CharT, class Traits>
-    friend std::basic_ostream<CharT,Traits>&
-    operator<<(std::basic_ostream<CharT,Traits>& os,
-               const mersenne_twister_engine& mt)
+    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, mersenne_twister_engine, mt)
     {
-        mt.print(os);
+        UIntType data[mt.state_size];
+        for (std::size_t j = 0; j < mt.i; ++j) {
+            data[j + mt.state_size - mt.i] = mt.x[j];
+        }
+        if (mt.i != mt.state_size) {
+            mt.rewind(&data[mt.state_size - mt.i - 1], mt.state_size - mt.i);
+        }
+        os << data[0];
+        for (std::size_t j = 1; j < mt.state_size; ++j) {
+            os << ' ' << data[j];
+        }
         return os;
     }
 
     /** Reads a mersenne_twister_engine from a @c std::istream */
-    template<class CharT, class Traits>
-    friend std::basic_istream<CharT,Traits>&
-    operator>>(std::basic_istream<CharT,Traits>& is,
-               mersenne_twister_engine& mt)
+    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, mersenne_twister_engine, mt)
     {
-        for(std::size_t j = 0; j < mt.state_size; ++j)
-            is >> mt.x[j] >> std::ws;
-        // MSVC (up to 7.1) and Borland (up to 5.64) don't handle the template
-        // value parameter "n" available from the class template scope, so use
-        // the static constant with the same value
+        is >> mt.x[0];
+        for(std::size_t j = 1; j < mt.state_size; ++j)
+            is >> std::ws >> mt.x[j];
         mt.i = mt.state_size;
         return is;
     }
@@ -286,26 +289,6 @@ class mersenne_twister_engine
         return true;
     }
 
-    /**
-     * Does the work of operator<<.  This is in a member function
-     * for portability.
-     */
-    template<class CharT, class Traits>
-    void print(std::basic_ostream<CharT, Traits>& os) const
-    {
-        UIntType data[n];
-        for(std::size_t j = 0; j < i; ++j) {
-            data[j + n - i] = x[j];
-        }
-        if(i != n) {
-            rewind(&data[n - i - 1], n - i);
-        }
-        os << data[0];
-        for(std::size_t j = 1; j < n; ++j) {
-            os << ' ' << data[j];
-        }
-    }
-
     /**
      * Copies z elements of the state preceding x[0] into
      * the array whose last element is last.
@@ -387,7 +370,7 @@ class mersenne_twister_engine
      * Sequences and Their Applications (SETA '08).
      * DOI=10.1007/978-3-540-85912-3_26
      */
-    void discard_many(boost::uintmax_t z)
+    void discard_many(std::uintmax_t z)
     {
         // Compute the minimal polynomial, phi(t)
         // This depends only on the transition function,
diff --git a/include/boost/random/mixmax.hpp b/include/boost/random/mixmax.hpp
index b3bbaf95c..2a3945f8a 100644
--- a/include/boost/random/mixmax.hpp
+++ b/include/boost/random/mixmax.hpp
@@ -121,14 +121,12 @@ class mixmax_engine{
     template<class CharT, class Traits>
     friend std::basic_ostream<CharT,Traits>&
     operator<< (std::basic_ostream<CharT,Traits>& ost, const mixmax_engine& me){
-        ost << Ndim << " " << me.S.counter << " " << me.S.sumtot << " ";
-        for (int j=0; (j< (Ndim) ); j++) {
-        ost <<  (std::uint64_t)me.S.V[j] << " ";
+        ost << Ndim << " " << me.S.counter << " " << me.S.sumtot;
+        for (const std::uint64_t v: me.S.V) {
+            ost << " " << v;
         }
-        ost << "\n";
-        ost.flush();
         return ost;
-        }
+    }
 
     /** read the state of the RNG from a stream */
     template<class CharT, class Traits>
@@ -141,16 +139,16 @@ class mixmax_engine{
         BOOST_ASSERT(counter==Ndim);
         in >> counter >> std::ws;
         in >> savedsum >> std::ws;
-        for(int j=0;j<Ndim;j++) {
-        in >> std::ws >> vec[j] ;
-        sum=me.MOD_MERSENNE(sum+vec[j]);
-    }
-    if (sum == savedsum && counter>0 && counter<Ndim){
-        me.S.V=vec; me.S.counter = counter; me.S.sumtot=savedsum;
-    }else{
-        in.setstate(std::ios::failbit);
-    }
-    return in;
+        for(std::uint64_t& v : vec) {
+            in >> std::ws >> v ;
+            sum=me.MOD_MERSENNE(sum+v);
+        }
+        if (sum == savedsum && counter>0 && counter<Ndim){
+            me.S.V=vec; me.S.counter = static_cast<int>(counter); me.S.sumtot=savedsum;
+        }else{
+            in.setstate(std::ios::failbit);
+        }
+        return in;
     }
 
 friend bool operator==(const mixmax_engine & x,
diff --git a/include/boost/random/negative_binomial_distribution.hpp b/include/boost/random/negative_binomial_distribution.hpp
index cbe26fad2..31dedb64c 100644
--- a/include/boost/random/negative_binomial_distribution.hpp
+++ b/include/boost/random/negative_binomial_distribution.hpp
@@ -14,8 +14,8 @@
 #define BOOST_RANDOM_NEGATIVE_BINOMIAL_DISTRIBUTION_HPP_INCLUDED
 
 #include <iosfwd>
+#include <limits>
 
-#include <boost/limits.hpp>
 #include <boost/random/detail/config.hpp>
 #include <boost/random/gamma_distribution.hpp>
 #include <boost/random/poisson_distribution.hpp>
diff --git a/include/boost/random/niederreiter_base2.hpp b/include/boost/random/niederreiter_base2.hpp
index 5f0585087..b5aae3fec 100644
--- a/include/boost/random/niederreiter_base2.hpp
+++ b/include/boost/random/niederreiter_base2.hpp
@@ -9,6 +9,9 @@
 #ifndef BOOST_RANDOM_NIEDERREITER_BASE2_HPP
 #define BOOST_RANDOM_NIEDERREITER_BASE2_HPP
 
+#include <cstdint>
+#include <limits>
+
 #include <boost/random/detail/niederreiter_base2_table.hpp>
 #include <boost/random/detail/gray_coded_qrng.hpp>
 
@@ -181,7 +184,7 @@ struct niederreiter_base2_lattice
           for (unsigned r = 0; r != bit_count; ++r) {
             value_type& num = cj[dimension * r + dim];
             // set the jth bit in num
-            num = (num & ~j) | (-v[r + u] & j);
+            num = (num & ~j) | (-static_cast<value_type>(v[r + u]) & j);
           }
         }
       } while (j != 0);
@@ -317,7 +320,7 @@ class niederreiter_base2_engine
   //!\endcode
   //!
   //!Throws: range_error.
-  void discard(boost::uintmax_t z)
+  void discard(std::uintmax_t z)
   {
     base_t::discard(z);
   }
@@ -351,7 +354,7 @@ class niederreiter_base2_engine
  *
  * However, it is possible to provide your own table to \niederreiter_base2_engine should the default one be insufficient.
  */
-typedef niederreiter_base2_engine<boost::uint_least64_t, 64u, default_niederreiter_base2_table> niederreiter_base2;
+typedef niederreiter_base2_engine<std::uint_least64_t, 64u, default_niederreiter_base2_table> niederreiter_base2;
 
 } // namespace random
 
diff --git a/include/boost/random/non_central_chi_squared_distribution.hpp b/include/boost/random/non_central_chi_squared_distribution.hpp
index 28c9ff6d9..4b4b3ae58 100644
--- a/include/boost/random/non_central_chi_squared_distribution.hpp
+++ b/include/boost/random/non_central_chi_squared_distribution.hpp
@@ -17,7 +17,7 @@
 #include <boost/config/no_tr1/cmath.hpp>
 #include <iosfwd>
 #include <istream>
-#include <boost/limits.hpp>
+#include <limits>
 #include <boost/random/detail/config.hpp>
 #include <boost/random/detail/operators.hpp>
 #include <boost/random/uniform_real_distribution.hpp>
diff --git a/include/boost/random/normal_distribution.hpp b/include/boost/random/normal_distribution.hpp
index b7ff3eba9..7009c626d 100644
--- a/include/boost/random/normal_distribution.hpp
+++ b/include/boost/random/normal_distribution.hpp
@@ -20,8 +20,8 @@
 #include <boost/config/no_tr1/cmath.hpp>
 #include <istream>
 #include <iosfwd>
+#include <limits>
 #include <boost/assert.hpp>
-#include <boost/limits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/random/detail/config.hpp>
 #include <boost/random/detail/operators.hpp>
diff --git a/include/boost/random/poisson_distribution.hpp b/include/boost/random/poisson_distribution.hpp
index 1281a7d85..33b5edd50 100644
--- a/include/boost/random/poisson_distribution.hpp
+++ b/include/boost/random/poisson_distribution.hpp
@@ -18,8 +18,8 @@
 #include <boost/config/no_tr1/cmath.hpp>
 #include <cstdlib>
 #include <iosfwd>
+#include <limits>
 #include <boost/assert.hpp>
-#include <boost/limits.hpp>
 #include <boost/random/uniform_01.hpp>
 #include <boost/random/detail/config.hpp>
 
diff --git a/include/boost/random/seed_seq.hpp b/include/boost/random/seed_seq.hpp
index fc7adbbf1..6d6e9cd56 100644
--- a/include/boost/random/seed_seq.hpp
+++ b/include/boost/random/seed_seq.hpp
@@ -14,8 +14,8 @@
 #ifndef BOOST_RANDOM_SEED_SEQ_HPP
 #define BOOST_RANDOM_SEED_SEQ_HPP
 
+#include <cstdint>
 #include <boost/config.hpp>
-#include <boost/cstdint.hpp>
 #include <cstddef>
 #include <vector>
 #include <algorithm>
@@ -36,7 +36,7 @@ namespace random {
  */
 class seed_seq {
 public:
-    typedef boost::uint_least32_t result_type;
+    typedef std::uint_least32_t result_type;
 
     /** Initializes a seed_seq to hold an empty sequence. */
     seed_seq() {}
diff --git a/include/boost/random/shuffle_order.hpp b/include/boost/random/shuffle_order.hpp
index 0dc6b26b6..a4b7c7cc1 100644
--- a/include/boost/random/shuffle_order.hpp
+++ b/include/boost/random/shuffle_order.hpp
@@ -15,13 +15,13 @@
 #ifndef BOOST_RANDOM_SHUFFLE_ORDER_HPP
 #define BOOST_RANDOM_SHUFFLE_ORDER_HPP
 
+#include <cstdint>
 #include <iostream>
 #include <algorithm>     // std::copy
 #include <cassert>
+#include <limits>
 #include <boost/config.hpp>
-#include <boost/limits.hpp>
 #include <boost/static_assert.hpp>
-#include <boost/cstdint.hpp>
 #include <boost/random/detail/operators.hpp>
 #include <boost/random/detail/seed.hpp>
 #include <boost/random/detail/signed_unsigned_tools.hpp>
@@ -149,8 +149,8 @@ class shuffle_order_engine
                 static_cast<uintmax_t>(off) * k /
                 (static_cast<uintmax_t>(brange) + 1));
         } else {
-            boost::uintmax_t divisor =
-                static_cast<boost::uintmax_t>(brange) + 1;
+            std::uintmax_t divisor =
+                static_cast<std::uintmax_t>(brange) + 1;
             j = static_cast<base_unsigned>(detail::muldiv(off, k, divisor));
         }
         // assert(0 <= j && j < k);
@@ -160,9 +160,9 @@ class shuffle_order_engine
     }
 
     /** Advances the generator by z steps. */
-    void discard(boost::uintmax_t z)
+    void discard(std::uintmax_t z)
     {
-        for(boost::uintmax_t j = 0; j < z; ++j) {
+        for(std::uintmax_t j = 0; j < z; ++j) {
             (*this)();
         }
     }
diff --git a/include/boost/random/sobol.hpp b/include/boost/random/sobol.hpp
index 042b3ba3a..6e177b1de 100644
--- a/include/boost/random/sobol.hpp
+++ b/include/boost/random/sobol.hpp
@@ -9,6 +9,8 @@
 #ifndef BOOST_RANDOM_SOBOL_HPP
 #define BOOST_RANDOM_SOBOL_HPP
 
+#include <cstdint>
+#include <limits>
 #include <boost/random/detail/sobol_table.hpp>
 #include <boost/random/detail/gray_coded_qrng.hpp>
 #include <boost/assert.hpp>
@@ -188,8 +190,8 @@ class sobol_engine
     return base_t::operator()();
   }
 
-  /** @copydoc boost::random::niederreiter_base2_engine::discard(boost::uintmax_t) */
-  void discard(boost::uintmax_t z)
+  /** @copydoc boost::random::niederreiter_base2_engine::discard(std::uintmax_t) */
+  void discard(std::uintmax_t z)
   {
     base_t::discard(z);
   }
@@ -229,7 +231,7 @@ class sobol_engine
  *
  * However, it is possible to provide your own table to \sobol_engine should the default one be insufficient.
  */
-typedef sobol_engine<boost::uint_least64_t, 64u, default_sobol_table> sobol;
+typedef sobol_engine<std::uint_least64_t, 64u, default_sobol_table> sobol;
 
 } // namespace random
 
diff --git a/include/boost/random/splitmix64.hpp b/include/boost/random/splitmix64.hpp
index 9ea10a623..dfb9b274f 100644
--- a/include/boost/random/splitmix64.hpp
+++ b/include/boost/random/splitmix64.hpp
@@ -11,7 +11,6 @@
 #define BOOST_RANDOM_SPLITMIX64_HPP
 
 #include <cstdint>
-#include <cstdlib>
 #include <limits>
 #include <array>
 #include <string>
@@ -142,8 +141,7 @@ class splitmix64
     inline friend std::basic_ostream<CharT,Traits>& operator<<(std::basic_ostream<CharT,Traits>& ost, 
                                                                const splitmix64& e)
     {
-        ost << e.state_;
-        return ost;
+        return ost << e.state_;
     }
 
     /**  Writes a @c splitmix64 to a @c std::istream. */
@@ -151,19 +149,7 @@ class splitmix64
     inline friend std::basic_istream<CharT,Traits>& operator>>(std::basic_istream<CharT,Traits>& ist,
                                                                splitmix64& e)
     {
-        std::string sstate;
-        CharT val;
-        while (ist >> val)
-        {
-            if (std::isdigit(val))
-            {
-                sstate.push_back(val);
-            }
-        }
-        
-        e.state_ = std::strtoull(sstate.c_str(), nullptr, 10);
-
-        return ist;
+        return ist >> e.state_;
     }
 
     /** Fills a range with random values */
diff --git a/include/boost/random/student_t_distribution.hpp b/include/boost/random/student_t_distribution.hpp
index e28b0e3bf..43919bfd8 100644
--- a/include/boost/random/student_t_distribution.hpp
+++ b/include/boost/random/student_t_distribution.hpp
@@ -15,8 +15,8 @@
 
 #include <boost/config/no_tr1/cmath.hpp>
 #include <iosfwd>
+#include <limits>
 #include <boost/config.hpp>
-#include <boost/limits.hpp>
 #include <boost/random/detail/operators.hpp>
 #include <boost/random/chi_squared_distribution.hpp>
 #include <boost/random/normal_distribution.hpp>
diff --git a/include/boost/random/subtract_with_carry.hpp b/include/boost/random/subtract_with_carry.hpp
index 6497884fa..36cfb257b 100644
--- a/include/boost/random/subtract_with_carry.hpp
+++ b/include/boost/random/subtract_with_carry.hpp
@@ -17,12 +17,12 @@
 #define BOOST_RANDOM_SUBTRACT_WITH_CARRY_HPP
 
 #include <boost/config/no_tr1/cmath.hpp>         // std::pow
+#include <cstdint>
 #include <iostream>
 #include <algorithm>     // std::equal
+#include <limits>
 #include <stdexcept>
 #include <boost/config.hpp>
-#include <boost/limits.hpp>
-#include <boost/cstdint.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/integer/static_log2.hpp>
 #include <boost/integer/integer_mask.hpp>
@@ -43,7 +43,7 @@ namespace detail {
 struct subtract_with_carry_discard
 {
     template<class Engine>
-    static void apply(Engine& eng, boost::uintmax_t z)
+    static void apply(Engine& eng, std::uintmax_t z)
     {
         typedef typename Engine::result_type IntType;
         const std::size_t short_lag = Engine::short_lag;
@@ -161,7 +161,7 @@ class subtract_with_carry_engine
                                         IntType, value)
     {
         typedef linear_congruential_engine<uint32_t,40014,0,2147483563> gen_t;
-        gen_t intgen(static_cast<boost::uint32_t>(value == 0 ? default_seed : value));
+        gen_t intgen(static_cast<std::uint32_t>(value == 0 ? default_seed : value));
         detail::generator_seed_seq<gen_t> gen(intgen);
         seed(gen);
     }
@@ -211,7 +211,7 @@ class subtract_with_carry_engine
     }
 
     /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z)
+    void discard(std::uintmax_t z)
     {
         detail::subtract_with_carry_discard::apply(*this, z);
     }
@@ -343,7 +343,7 @@ class subtract_with_carry_01_engine
     BOOST_STATIC_CONSTANT(std::size_t, word_size = w);
     BOOST_STATIC_CONSTANT(std::size_t, long_lag = r);
     BOOST_STATIC_CONSTANT(std::size_t, short_lag = s);
-    BOOST_STATIC_CONSTANT(boost::uint32_t, default_seed = 19780503u);
+    BOOST_STATIC_CONSTANT(std::uint32_t, default_seed = 19780503u);
 
     BOOST_STATIC_ASSERT(!std::numeric_limits<result_type>::is_integer);
 
@@ -351,7 +351,7 @@ class subtract_with_carry_01_engine
     subtract_with_carry_01_engine() { init_modulus(); seed(); }
     /** Creates a new subtract_with_carry_01_engine and seeds it with value. */
     BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(subtract_with_carry_01_engine,
-                                               boost::uint32_t, value)
+                                               std::uint32_t, value)
     { init_modulus(); seed(value); }
     /**
      * Creates a new \subtract_with_carry_01_engine and seeds with values
@@ -389,7 +389,7 @@ class subtract_with_carry_01_engine
 
     /** Seeds the generator with @c value. */
     BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(subtract_with_carry_01_engine,
-                                        boost::uint32_t, value)
+                                        std::uint32_t, value)
     {
         typedef linear_congruential_engine<uint32_t, 40014, 0, 2147483563> gen_t;
         gen_t intgen(value == 0 ? default_seed : value);
@@ -443,7 +443,7 @@ class subtract_with_carry_01_engine
     }
 
     /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z)
+    void discard(std::uintmax_t z)
     { detail::subtract_with_carry_discard::apply(*this, z); }
 
     /** Fills a range with random values. */
diff --git a/include/boost/random/uniform_01.hpp b/include/boost/random/uniform_01.hpp
index 37258f580..291a33915 100644
--- a/include/boost/random/uniform_01.hpp
+++ b/include/boost/random/uniform_01.hpp
@@ -17,8 +17,8 @@
 #define BOOST_RANDOM_UNIFORM_01_HPP
 
 #include <iostream>
+#include <limits>
 #include <boost/config.hpp>
-#include <boost/limits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/random/detail/config.hpp>
 #include <boost/random/detail/ptr_helper.hpp>
diff --git a/include/boost/random/uniform_int_distribution.hpp b/include/boost/random/uniform_int_distribution.hpp
index a70c4d188..a0291444c 100644
--- a/include/boost/random/uniform_int_distribution.hpp
+++ b/include/boost/random/uniform_int_distribution.hpp
@@ -21,8 +21,8 @@
 #include <iosfwd>
 #include <ios>
 #include <istream>
+#include <limits>
 #include <boost/config.hpp>
-#include <boost/limits.hpp>
 #include <boost/assert.hpp>
 #include <boost/random/detail/config.hpp>
 #include <boost/random/detail/operators.hpp>
diff --git a/include/boost/random/uniform_real.hpp b/include/boost/random/uniform_real.hpp
index c98626e77..906652f8d 100644
--- a/include/boost/random/uniform_real.hpp
+++ b/include/boost/random/uniform_real.hpp
@@ -19,7 +19,6 @@
 
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
-#include <boost/limits.hpp>
 #include <boost/random/uniform_real_distribution.hpp>
 
 namespace boost {
diff --git a/include/boost/random/uniform_real_distribution.hpp b/include/boost/random/uniform_real_distribution.hpp
index 9eab9f4bc..6bd9ccdca 100644
--- a/include/boost/random/uniform_real_distribution.hpp
+++ b/include/boost/random/uniform_real_distribution.hpp
@@ -18,6 +18,7 @@
 #include <iosfwd>
 #include <ios>
 #include <istream>
+#include <limits>
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
 #include <boost/random/detail/config.hpp>
diff --git a/include/boost/random/uniform_smallint.hpp b/include/boost/random/uniform_smallint.hpp
index d8f0cd3ba..3448914e7 100644
--- a/include/boost/random/uniform_smallint.hpp
+++ b/include/boost/random/uniform_smallint.hpp
@@ -19,9 +19,9 @@
 
 #include <istream>
 #include <iosfwd>
+#include <limits>
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
-#include <boost/limits.hpp>
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/random/detail/config.hpp>
 #include <boost/random/detail/operators.hpp>
diff --git a/include/boost/random/weibull_distribution.hpp b/include/boost/random/weibull_distribution.hpp
index 55e3c0490..1dd8e4ef9 100644
--- a/include/boost/random/weibull_distribution.hpp
+++ b/include/boost/random/weibull_distribution.hpp
@@ -16,8 +16,8 @@
 #include <boost/config/no_tr1/cmath.hpp>
 #include <iosfwd>
 #include <istream>
+#include <limits>
 #include <boost/config.hpp>
-#include <boost/limits.hpp>
 #include <boost/random/detail/operators.hpp>
 #include <boost/random/uniform_01.hpp>
 
diff --git a/include/boost/random/xor_combine.hpp b/include/boost/random/xor_combine.hpp
index 312fdb8db..5e5179132 100644
--- a/include/boost/random/xor_combine.hpp
+++ b/include/boost/random/xor_combine.hpp
@@ -14,13 +14,12 @@
 #ifndef BOOST_RANDOM_XOR_COMBINE_HPP
 #define BOOST_RANDOM_XOR_COMBINE_HPP
 
+#include <cstdint>
 #include <istream>
 #include <iosfwd>
 #include <cassert>
 #include <algorithm> // for std::min and std::max
 #include <boost/config.hpp>
-#include <boost/limits.hpp>
-#include <boost/cstdint.hpp>     // uint32_t
 #include <boost/random/detail/config.hpp>
 #include <boost/random/detail/seed.hpp>
 #include <boost/random/detail/seed_impl.hpp>
@@ -128,7 +127,7 @@ class xor_combine_engine
     { detail::generate_from_int(*this, first, last); }
 
     /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z)
+    void discard(std::uintmax_t z)
     {
         _rng1.discard(z);
         _rng2.discard(z);
diff --git a/include/boost/random/xoshiro.hpp b/include/boost/random/xoshiro.hpp
index 92c3bc38c..98626e995 100644
--- a/include/boost/random/xoshiro.hpp
+++ b/include/boost/random/xoshiro.hpp
@@ -17,6 +17,7 @@
 #include <boost/core/bit.hpp>
 #include <array>
 #include <cstdint>
+#include <limits>
 
 namespace boost {
 namespace random {
diff --git a/performance/random_speed.cpp b/performance/random_speed.cpp
index 7f51e4c5b..467e9a357 100644
--- a/performance/random_speed.cpp
+++ b/performance/random_speed.cpp
@@ -12,6 +12,7 @@
 #include <iostream>
 #include <cstdlib>
 #include <string>
+#include <limits>
 #include <boost/config.hpp>
 #include <boost/random.hpp>
 #include <boost/progress.hpp>
@@ -327,10 +328,10 @@ int main(int argc, char*argv[])
 #if !defined(BOOST_NO_INT64_T) && \
     !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION)
   run(iter, "rand48", boost::rand48());
-  linear_congruential<boost::uint64_t>
-    lcg48(boost::uint64_t(1)<<16 | 0x330e,
-          boost::uint64_t(0xDEECE66DUL) | (boost::uint64_t(0x5) << 32), 0xB,
-          boost::uint64_t(1)<<48);
+  linear_congruential<std::uint64_t>
+    lcg48(std::uint64_t(1)<<16 | 0x330e,
+          std::uint64_t(0xDEECE66DUL) | (std::uint64_t(0x5) << 32), 0xB,
+          std::uint64_t(1)<<48);
   timing(lcg48, iter, "lrand48 run-time");
 #endif
 
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 443dc320f..2e1cd5262 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,30 +1,58 @@
 # Copyright 2018, 2019 Peter Dimov
 # Copyright 2023 Matt Borland
+# Copyright 2026 Alexander Grund
 # Distributed under the Boost Software License, Version 1.0.
 # See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
 
-include(BoostTestJamfile OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)
+include(BoostTest OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)
 
 if(HAVE_BOOST_TEST)
 
-    boost_test_jamfile(FILE Jamfile.v2 LINK_LIBRARIES
-            Boost::random
-            Boost::array
-            Boost::assert
-            Boost::config
-            Boost::core
-            Boost::dynamic_bitset
-            Boost::exception
-            Boost::integer
-            Boost::io
-            Boost::lexical_cast
-            Boost::math
-            Boost::multiprecision
-            Boost::numeric_conversion
-            Boost::range
-            Boost::system
-            Boost::throw_exception
-            Boost::type_traits
-            Boost::utility)
+  file(STRINGS "Jamfile.v2" data)
 
+  foreach(line IN LISTS data)
+    if(line MATCHES "^[ \t]*run[ \t]+(.+)")
+      set(args "${CMAKE_MATCH_1}")
+      if(args MATCHES "multiprecision_.+_test")
+        continue()
+      elseif(NOT args MATCHES "^([^:;]+)[ \t]*;[ \t]*$")
+        boost_message(AUTHOR_WARNING "boost_test_jamfile: Unknown Jamfile line: ${line}\n'${args}'")
+        continue()
+      endif()
+      string(REPLACE " " ";" parts "${CMAKE_MATCH_1}")
+      set(sources )
+      set(extra_libs )
+      foreach(part IN ITEMS ${parts})
+        if(part MATCHES "^[./a-zA-Z0-9_]+\.cpp+$")
+            list(APPEND sources ${part})
+        elseif(part STREQUAL "/boost/iterator//boost_iterator")
+            list(APPEND extra_libs Boost::iterator)
+        elseif(part STREQUAL "/boost/range//boost_range")
+            list(APPEND extra_libs Boost::range)
+        elseif(part STREQUAL "/boost/test//boost_unit_test_framework")
+            list(APPEND extra_libs Boost::unit_test_framework)
+        elseif(part STREQUAL "math_test")
+            list(APPEND extra_libs Boost::exception Boost::lexical_cast Boost::math Boost::numeric_conversion Boost::range)
+        else()
+            boost_message(SEND_ERROR "Unknown dependency '${part}'")
+        endif()
+      endforeach()
+      if(sources MATCHES "^test_lagged_fibonacci[0-9]+")
+        # Larger ones overflow the stack, see comment in Jamfile
+        set(type compile)
+      else()
+        set(type run)
+      endif()
+      boost_test(TYPE ${type} SOURCES ${sources} LINK_LIBRARIES Boost::random ${extra_libs})
+    endif()
+  endforeach()
 endif()
+
+boost_test(TYPE run SOURCES multiprecision_int_test.cpp
+           LINK_LIBRARIES Boost::random Boost::unit_test_framework Boost::multiprecision
+           COMPILE_FEATURES cxx_std_14)
+boost_test(TYPE compile SOURCES multiprecision_float_test.cpp
+           LINK_LIBRARIES Boost::random Boost::unit_test_framework Boost::multiprecision
+           COMPILE_FEATURES cxx_std_14)
+boost_test(TYPE compile SOURCES statistic_tests.cpp
+           LINK_LIBRARIES Boost::random Boost::math)
diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
index 17157527d..414b1c2a7 100644
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -1,7 +1,8 @@
 # Copyright 2003 Jens Maurer
 # Copyright 2009-2011 Steven Watanabe
-# Distributed under the Boost Software License, Version 1.0. (See accompany-
-# ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+# Copyright 2026 Alexander Grund
+# 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)
 
 # Boost Random Library test Jamfile
 
@@ -24,9 +25,8 @@ project /boost/random/test : requirements
 run test_const_mod.cpp /boost/test//boost_unit_test_framework ;
 run test_generate_canonical.cpp /boost/test//boost_unit_test_framework ;
 run test_random_number_generator.cpp /boost/test//boost_unit_test_framework ;
-run ../example/random_demo.cpp ;
-run test_random_device.cpp /boost/random//boost_random /boost/test//included : : : <link>static : test_random_device ;
-run test_random_device.cpp /boost/random//boost_random /boost/test//included : : : <link>shared : test_random_device_dll ;
+run ../example/random_demo.cpp /boost/iterator//boost_iterator ;
+run test_random_device.cpp /boost/test//boost_unit_test_framework ;
 
 run test_minstd_rand0.cpp /boost/test//boost_unit_test_framework ;
 run test_minstd_rand.cpp /boost/test//boost_unit_test_framework ;
@@ -103,21 +103,21 @@ explicit test_lagged_fibonacci1279 test_lagged_fibonacci2281
     test_lagged_fibonacci44497 ;
 
 alias math_test :
-    /boost/assign//boost_assign
     /boost/exception//boost_exception
     /boost/lexical_cast//boost_lexical_cast
     /boost/math//boost_math_tr1
     /boost/numeric_conversion//boost_numeric_conversion
+    /boost/range//boost_range
     ;
 
-run test_seed_seq.cpp /boost/assign//boost_assign /boost/test//boost_unit_test_framework ;
+run test_seed_seq.cpp /boost/test//boost_unit_test_framework ;
 
 run test_binomial.cpp math_test ;
 run test_binomial_distribution.cpp /boost/test//boost_unit_test_framework ;
 run test_poisson.cpp math_test ;
 run test_poisson_distribution.cpp /boost/test//boost_unit_test_framework ;
 run test_discrete.cpp math_test ;
-run test_discrete_distribution.cpp /boost/assign//boost_assign /boost/test//boost_unit_test_framework ;
+run test_discrete_distribution.cpp /boost/test//boost_unit_test_framework ;
 run test_gamma.cpp math_test ;
 run test_gamma_distribution.cpp /boost/test//boost_unit_test_framework ;
 run test_weibull.cpp math_test ;
@@ -135,9 +135,9 @@ run test_student_t_distribution.cpp /boost/test//boost_unit_test_framework ;
 run test_normal.cpp math_test ;
 run test_normal_distribution.cpp /boost/test//boost_unit_test_framework ;
 run test_piecewise_constant.cpp math_test ;
-run test_piecewise_constant_distribution.cpp /boost/assign//boost_assign /boost/test//boost_unit_test_framework ;
+run test_piecewise_constant_distribution.cpp /boost/test//boost_unit_test_framework ;
 run test_piecewise_linear.cpp math_test ;
-run test_piecewise_linear_distribution.cpp /boost/assign//boost_assign /boost/test//boost_unit_test_framework ;
+run test_piecewise_linear_distribution.cpp /boost/test//boost_unit_test_framework ;
 run test_exponential.cpp math_test ;
 run test_exponential_distribution.cpp /boost/test//boost_unit_test_framework ;
 run test_bernoulli.cpp math_test ;
diff --git a/test/cmake_test/CMakeLists.txt b/test/cmake_test/CMakeLists.txt
new file mode 100644
index 000000000..e82ad2a2f
--- /dev/null
+++ b/test/cmake_test/CMakeLists.txt
@@ -0,0 +1,52 @@
+# Copyright 2021-2026 Alexander Grund
+# 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
+
+cmake_minimum_required(VERSION 3.5...3.31)
+
+project(cmake_subdir_test LANGUAGES CXX)
+
+# Those 2 should work the same
+# while using find_package for the installed Boost avoids the need to manually specify dependencies
+if(BOOST_CI_INSTALL_TEST)
+    # Regular usage:
+    # Provides target Boost::random
+    find_package(Boost COMPONENTS random REQUIRED)
+else()
+    add_subdirectory(../.. boostorg/random)
+
+    set(deps
+      # Primary dependencies
+      assert
+      config
+      core
+      dynamic_bitset
+      integer
+      io
+      system
+      throw_exception
+      type_traits
+      utility
+      # Secondary dependencies
+      compat
+      container_hash
+      describe
+      mp11
+      predef
+      preprocessor
+      variant2
+      winapi
+    )
+
+    foreach(dep IN LISTS deps)
+      add_subdirectory(../../../${dep} boostorg/${dep})
+    endforeach()
+endif()
+
+add_executable(main main.cpp)
+target_link_libraries(main Boost::random)
+
+enable_testing()
+add_test(NAME main COMMAND main)
+
+add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)
diff --git a/test/cmake_test/main.cpp b/test/cmake_test/main.cpp
new file mode 100644
index 000000000..7cfcbf8ae
--- /dev/null
+++ b/test/cmake_test/main.cpp
@@ -0,0 +1,9 @@
+#include <boost/random.hpp>
+
+int main()
+{
+  boost::mt19937 rng;
+  boost::uniform_int<> six(1,6);
+  int x = six(rng);       
+  return (x >= 1 && x <= 6) ? 0 : 1;
+}
diff --git a/test/concepts.hpp b/test/concepts.hpp
index 700036766..12f34f186 100644
--- a/test/concepts.hpp
+++ b/test/concepts.hpp
@@ -33,10 +33,11 @@
 #include <boost/type_traits/is_arithmetic.hpp>
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <boost/cstdint.hpp>
 #include <boost/static_assert.hpp>
+#include <cstdint>
 #include <istream>
 #include <ostream>
+#include <vector>
 
 #ifdef BOOST_MSVC
 #pragma warning(push)
@@ -78,7 +79,7 @@ struct SeedSeq
     }
 private:
     SSeq q;
-    mutable_random_access_iterator_archetype<boost::uint32_t> rb, re;
+    mutable_random_access_iterator_archetype<std::uint32_t> rb, re;
 };
 
 template<class T>
@@ -157,7 +158,7 @@ struct RandomNumberEngine :
     typename boost::random::detail::seed_type<result_type>::type s;
     uintmax_t z;
     
-    input_iterator_archetype<boost::uint32_t> sb, se;
+    input_iterator_archetype<std::uint32_t> sb, se;
 };
 
 template<class D>
@@ -211,4 +212,9 @@ struct RandomNumberDistribution :
 #pragma warning(pop)
 #endif
 
+template<typename T, typename... U>
+std::vector<T> make_vector(const T t1, U... u){
+    return std::vector<T>{ t1, static_cast<T>(u)... };
+}
+
 #endif
diff --git a/test/integrate.hpp b/test/integrate.hpp
index 33766acd6..3864c984d 100644
--- a/test/integrate.hpp
+++ b/test/integrate.hpp
@@ -1,20 +1,21 @@
 /* integrate.hpp header file
  *
  * Copyright Jens Maurer 2000
+ * Copyright Alexander Grund 2026
  * 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)
  *
  * $Id$
  *
- * Revision history
- *   01 April 2001: Modified to use new <boost/limits.hpp> header. (JMaddock)
  */
 
 #ifndef INTEGRATE_HPP
 #define INTEGRATE_HPP
 
-#include <boost/limits.hpp>
+#include <boost/utility/result_of.hpp>
+
+#include <limits>
 
 template<class UnaryFunction>
 inline typename UnaryFunction::result_type 
@@ -45,7 +46,7 @@ simpson(UnaryFunction f, typename UnaryFunction::argument_type a,
 // compute b so that f(b) = y; assume f is monotone increasing
 template<class UnaryFunction, class T>
 inline T
-invert_monotone_inc(UnaryFunction f, typename UnaryFunction::result_type y,
+invert_monotone_inc(UnaryFunction f, typename boost::result_of<UnaryFunction(T)>::type y,
                     T lower = -1,
                     T upper = 1)
 {
diff --git a/test/multiprecision_float_test.cpp b/test/multiprecision_float_test.cpp
index 2b5348330..2b59569a0 100644
--- a/test/multiprecision_float_test.cpp
+++ b/test/multiprecision_float_test.cpp
@@ -22,6 +22,7 @@
 #include <boost/random.hpp>
 #include <boost/mpl/list.hpp>
 #include <sstream>
+#include <limits>
 
 
 typedef boost::multiprecision::number<boost::multiprecision::cpp_bin_float_100::backend_type, boost::multiprecision::et_on > big_float;
@@ -88,13 +89,43 @@ typedef boost::mpl::list <
    boost::random::weibull_distribution<big_float>
 > distributions;
 
+template<class T>
+void check_result(const T& result, const T& min_val, const T& max_val)
+{
+
+   BOOST_CHECK(boost::math::isfinite(result));
+   BOOST_TEST(result >= min_val);
+   BOOST_TEST(result <= max_val);
+}
+
+template<class T>
+void check_result(const std::vector<T>& result, const std::vector<T>& min_val, const std::vector<T>& max_val)
+{
+   for(size_t i = 0; i < result.size(); i++)
+   {
+      BOOST_CHECK(boost::math::isfinite(result[i]));
+   }
+   BOOST_TEST(result >= min_val);
+   BOOST_TEST(result <= max_val);
+}
+
+template<class TDist, class TGen>
+void do_check_distribution(TDist& d, TGen& gen)
+{
+   typedef typename TDist::result_type result_type;
+   const result_type min_val = (d.min)();
+   const result_type max_val = (d.max)();
+   for(unsigned i = 0; i < 200; ++i)
+   {
+      result_type r = d(gen);
+      check_result(r, min_val, max_val);
+   }
+}
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(distributions_test, dist_type, distributions)
 {
    typedef typename dist_type::result_type result_type;
    dist_type d;
-   result_type a = (d.min)();
-   result_type b = (d.max)();
    typename dist_type::param_type p = d.param();
    boost::ignore_unused(p);
    d.reset();
@@ -106,46 +137,16 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(distributions_test, dist_type, distributions)
    BOOST_CHECK(d == d2);
 
    boost::random::mt19937 int_gen;
+   do_check_distribution(d, int_gen);
 
-   for(unsigned i = 0; i < 200; ++i)
-   {
-      result_type r = d(int_gen);
-      BOOST_CHECK((boost::math::isfinite)(r));
-      BOOST_CHECK(r >= a);
-      BOOST_CHECK(r <= b);
-   }
-
-#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
    large_int_generator big_int_gen;
-
-   for(unsigned i = 0; i < 200; ++i)
-   {
-      result_type r = d(big_int_gen);
-      BOOST_CHECK((boost::math::isfinite)(r));
-      BOOST_CHECK(r >= a);
-      BOOST_CHECK(r <= b);
-   }
+   do_check_distribution(d, big_int_gen);
 
    boost::random::discard_block_engine< ranlux_big_base_01, 389, 24 > big_float_gen;
-
-   for(unsigned i = 0; i < 200; ++i)
-   {
-      result_type r = d(big_float_gen);
-      BOOST_CHECK((boost::math::isfinite)(r));
-      BOOST_CHECK(r >= a);
-      BOOST_CHECK(r <= b);
-   }
-#endif
+   do_check_distribution(d, big_float_gen);
 
    boost::random::ranlux64_4_01 float_gen;
-
-   for(unsigned i = 0; i < 200; ++i)
-   {
-      result_type r = d(float_gen);
-      BOOST_CHECK((boost::math::isfinite)(r));
-      BOOST_CHECK(r >= a);
-      BOOST_CHECK(r <= b);
-   }
+   do_check_distribution(d, float_gen);
 }
 
 
diff --git a/test/multiprecision_int_test.cpp b/test/multiprecision_int_test.cpp
index a861cca39..0fe030c2b 100644
--- a/test/multiprecision_int_test.cpp
+++ b/test/multiprecision_int_test.cpp
@@ -34,6 +34,7 @@
 #include <boost/random/discrete_distribution.hpp>
 #include <boost/mpl/list.hpp>
 #include <sstream>
+#include <limits>
 
 typedef boost::mpl::list <
    boost::random::independent_bits_engine<boost::random::mt19937, 1024, boost::multiprecision::uint1024_t >,
@@ -160,10 +161,10 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(distributions, distribution_type, uniform_distribu
    distribution_type d(a, b);
    boost::random::mt19937 gen;
 
-   BOOST_CHECK_EQUAL(d.a(), a);
-   BOOST_CHECK_EQUAL(d.b(), b);
-   BOOST_CHECK_EQUAL((d.min)(), a);
-   BOOST_CHECK_EQUAL((d.max)(), b);
+   BOOST_TEST(d.a() == a);
+   BOOST_TEST(d.b() == b);
+   BOOST_TEST((d.min)() == a);
+   BOOST_TEST((d.max)() == b);
 
    for(unsigned i = 0; i < 200; ++i)
    {
@@ -208,6 +209,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(discrete_distributions, distribution_type, other_d
    for(unsigned i = 0; i < 200; ++i)
    {
       result_type r = d(gen);
+      boost::ignore_unused(r);
    }
 
    std::stringstream ss;
@@ -223,6 +225,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(discrete_distributions, distribution_type, other_d
    for(unsigned i = 0; i < 200; ++i)
    {
       result_type r = d(big_random);
+      boost::ignore_unused(r);
    }
 }
 
diff --git a/test/statistic_tests.cpp b/test/statistic_tests.cpp
index 717985b26..afdbac791 100644
--- a/test/statistic_tests.cpp
+++ b/test/statistic_tests.cpp
@@ -17,8 +17,8 @@
 #include <vector>
 #include <set>
 #include <algorithm>
+#include <limits>
 
-#include <boost/cstdint.hpp>
 #include <boost/random.hpp>
 
 #include <boost/math/special_functions/gamma.hpp>
diff --git a/test/statistic_tests.hpp b/test/statistic_tests.hpp
index c1feb5559..224c5503a 100644
--- a/test/statistic_tests.hpp
+++ b/test/statistic_tests.hpp
@@ -12,15 +12,15 @@
 #ifndef STATISTIC_TESTS_HPP
 #define STATISTIC_TESTS_HPP
 
-#include <stdexcept>
-#include <iterator>
-#include <vector>
-#include <boost/limits.hpp>
 #include <algorithm>
 #include <cmath>
+#include <functional>
+#include <iterator>
+#include <limits>
+#include <stdexcept>
+#include <vector>
 
 #include <boost/config.hpp>
-#include <boost/bind.hpp>
 #include <boost/random/uniform_01.hpp>
 #include <boost/random/variate_generator.hpp>
 
@@ -491,7 +491,8 @@ inline double cdf(const kolmogorov_smirnov_probability& dist, double val)
 
 inline double quantile(const kolmogorov_smirnov_probability& dist, double val)
 {
-    return invert_monotone_inc(boost::bind(&cdf, dist, _1), val, 0.0, 1000.0);
+    using namespace std::placeholders;
+    return invert_monotone_inc(std::bind(&cdf, dist, _1), val, 0.0, 1000.0);
 }
 
 /*
@@ -644,8 +645,8 @@ double run_experiment(const Experiment & experiment, Generator & gen, int n)
   generic_counter<std::vector<int> > v(experiment.classes());
   experiment.run(gen, v, n);
   return chi_square_value(v.begin(), v.end(),
-                          boost::bind(&Experiment::probability, 
-                                       experiment, boost::placeholders::_1));
+                          std::bind(&Experiment::probability, 
+                                    experiment, std::placeholders::_1));
 }
 
 // chi_square test
@@ -655,8 +656,8 @@ double run_experiment(const Experiment & experiment, const Generator & gen, int
   generic_counter<std::vector<int> > v(experiment.classes());
   experiment.run(gen, v, n);
   return chi_square_value(v.begin(), v.end(),
-                          boost::bind(&Experiment::probability, 
-                                       experiment, boost::placeholders::_1));
+                          std::bind(&Experiment::probability, 
+                                    experiment, std::placeholders::_1));
 }
 
 // number generator with experiment results (for nesting)
diff --git a/test/test_beta_distribution.cpp b/test/test_beta_distribution.cpp
index 4d66b017e..03c6bbb59 100644
--- a/test/test_beta_distribution.cpp
+++ b/test/test_beta_distribution.cpp
@@ -10,7 +10,6 @@
  */
 
 #include <boost/random/beta_distribution.hpp>
-#include <limits>
 
 #define BOOST_RANDOM_DISTRIBUTION boost::random::beta_distribution<>
 #define BOOST_RANDOM_ARG1 alpha
diff --git a/test/test_comp_xoshiro128pp.cpp b/test/test_comp_xoshiro128pp.cpp
index ac05b6da8..a40b509ed 100644
--- a/test/test_comp_xoshiro128pp.cpp
+++ b/test/test_comp_xoshiro128pp.cpp
@@ -108,9 +108,9 @@ void long_jump(void) {
     uint32_t s1 = 0;
     uint32_t s2 = 0;
     uint32_t s3 = 0;
-    for(int i = 0; i < sizeof LONG_JUMP / sizeof *LONG_JUMP; i++)
+    for(const uint32_t jump: LONG_JUMP)
         for(int b = 0; b < 32; b++) {
-            if (LONG_JUMP[i] & UINT32_C(1) << b) {
+            if (jump & UINT32_C(1) << b) {
                 s0 ^= s[0];
                 s1 ^= s[1];
                 s2 ^= s[2];
diff --git a/test/test_const_mod.cpp b/test/test_const_mod.cpp
index 5d18eba7e..c2ea83d40 100644
--- a/test/test_const_mod.cpp
+++ b/test/test_const_mod.cpp
@@ -11,27 +11,28 @@
 
 #include <boost/random/detail/const_mod.hpp>
 
-#include <boost/cstdint.hpp>
+#include <cstdint>
+#include <limits>
 #include <boost/mpl/vector.hpp>
 
 #define BOOST_TEST_MAIN
 #include <boost/test/unit_test.hpp>
 
 typedef boost::mpl::vector<
-    boost::int8_t,
-    boost::uint8_t
+    std::int8_t,
+    std::uint8_t
 > int8_types;
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(test_mult8, IntType, int8_types) {
     for(int i = 0; i < 127; ++i) {
         for(int j = 0; j < 127; ++j) {
-            BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 127>::mult(IntType(i), IntType(j))), i * j % 127);
+            BOOST_TEST((boost::random::const_mod<IntType, 127>::mult(IntType(i), IntType(j))) == i * j % 127);
         }
     }
     int modulus = (std::numeric_limits<IntType>::max)() + 1;
     for(int i = 0; i < modulus; ++i) {
         for(int j = 0; j < modulus; ++j) {
-            BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 0>::mult(IntType(i), IntType(j))), i * j % modulus);
+            BOOST_TEST((boost::random::const_mod<IntType, 0>::mult(IntType(i), IntType(j))) == i * j % modulus);
         }
     }
 }
@@ -39,14 +40,14 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_mult8, IntType, int8_types) {
 BOOST_AUTO_TEST_CASE_TEMPLATE(test_add8, IntType, int8_types) {
     for(int i = 0; i < 127; ++i) {
         for(int j = 0; j < 127; ++j) {
-            BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 127>::add(IntType(i), IntType(j))), (i + j) % 127);
+            BOOST_TEST((boost::random::const_mod<IntType, 127>::add(IntType(i), IntType(j))) == (i + j) % 127);
         }
     }
     {
     const int modulus = boost::integer_traits<IntType>::const_max;
     for(int i = 0; i < modulus; ++i) {
         for(int j = 0; j < modulus; ++j) {
-            BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, modulus>::add(IntType(i), IntType(j))), (i + j) % modulus);
+            BOOST_TEST((boost::random::const_mod<IntType, modulus>::add(IntType(i), IntType(j))) == (i + j) % modulus);
         }
     }
     }
@@ -54,7 +55,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_add8, IntType, int8_types) {
     int modulus = (std::numeric_limits<IntType>::max)() + 1;
     for(int i = 0; i < modulus; ++i) {
         for(int j = 0; j < modulus; ++j) {
-            BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 0>::add(IntType(i), IntType(j))), (i + j) % modulus);
+            BOOST_TEST((boost::random::const_mod<IntType, 0>::add(IntType(i), IntType(j))) == (i + j) % modulus);
         }
     }
     }
@@ -64,7 +65,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_mult_add8, IntType, int8_types) {
     for(int i = 0; i < 127; i += 5) {
         for(int j = 0; j < 127; j += 3) {
             for(int k = 0; k < 127; k += 3) {
-                BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 127>::mult_add(IntType(i), IntType(j), IntType(k))), (i * j + k) % 127);
+                BOOST_TEST((boost::random::const_mod<IntType, 127>::mult_add(IntType(i), IntType(j), IntType(k))) == (i * j + k) % 127);
             }
         }
     }
@@ -73,7 +74,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_mult_add8, IntType, int8_types) {
     for(int i = 0; i < modulus; i += 5) {
         for(int j = 0; j < modulus; j += 3) {
             for(int k = 0; k < modulus; k += 3) {
-                BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 0>::mult_add(IntType(i), IntType(j), IntType(k))), (i * j + k) % modulus);
+                BOOST_TEST((boost::random::const_mod<IntType, 0>::mult_add(IntType(i), IntType(j), IntType(k))) == (i * j + k) % modulus);
             }
         }
     }
@@ -83,101 +84,101 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_mult_add8, IntType, int8_types) {
 BOOST_AUTO_TEST_CASE_TEMPLATE(test_invert8, IntType, int8_types) {
     for(int i = 1; i < 127; ++i) {
         IntType inverse = boost::random::const_mod<IntType, 127>::invert(IntType(i));
-        BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 127>::mult(IntType(i), inverse)), 1);
+        BOOST_TEST((boost::random::const_mod<IntType, 127>::mult(IntType(i), inverse)) == 1);
     }
     int modulus = (std::numeric_limits<IntType>::max)() + 1;
     for(int i = 1; i < modulus; i += 2) {
         IntType inverse = boost::random::const_mod<IntType, 0>::invert(IntType(i));
-        BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 0>::mult(IntType(i), inverse)), 1);
+        BOOST_TEST((boost::random::const_mod<IntType, 0>::mult(IntType(i), inverse)) == 1);
     }
 }
 
 typedef boost::mpl::vector<
-    boost::int32_t,
-    boost::uint32_t
+    std::int32_t,
+    std::uint32_t
 > int32_types;
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(test_mult32, IntType, int32_types) {
-    BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 2147483563>::mult(0, 0)), IntType(0));
-    BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 2147483563>::mult(0, 2147483562)), IntType(0));
-    BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 2147483563>::mult(2147483562, 0)), IntType(0));
-    BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 2147483563>::mult(2147483562, 2147483562)), IntType(1));
-    BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 2147483563>::mult(1234567890, 1234657890)), IntType(813106682));
+    BOOST_TEST((boost::random::const_mod<IntType, 2147483563>::mult(0, 0)) == IntType(0));
+    BOOST_TEST((boost::random::const_mod<IntType, 2147483563>::mult(0, 2147483562)) == IntType(0));
+    BOOST_TEST((boost::random::const_mod<IntType, 2147483563>::mult(2147483562, 0)) == IntType(0));
+    BOOST_TEST((boost::random::const_mod<IntType, 2147483563>::mult(2147483562, 2147483562)) == IntType(1));
+    BOOST_TEST((boost::random::const_mod<IntType, 2147483563>::mult(1234567890, 1234657890)) == IntType(813106682));
 }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(test_add32, IntType, int32_types) {
-    BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 2147483563>::add(0, 0)), IntType(0));
-    BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 2147483563>::add(0, 2147483562)), IntType(2147483562));
-    BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 2147483563>::add(2147483562, 0)), IntType(2147483562));
-    BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 2147483563>::add(2147483562, 2147483562)), IntType(2147483561));
-    BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 2147483563>::add(1234567890, 1234657890)), IntType(321742217));
+    BOOST_TEST((boost::random::const_mod<IntType, 2147483563>::add(0, 0)) == IntType(0));
+    BOOST_TEST((boost::random::const_mod<IntType, 2147483563>::add(0, 2147483562)) == IntType(2147483562));
+    BOOST_TEST((boost::random::const_mod<IntType, 2147483563>::add(2147483562, 0)) == IntType(2147483562));
+    BOOST_TEST((boost::random::const_mod<IntType, 2147483563>::add(2147483562, 2147483562)) == IntType(2147483561));
+    BOOST_TEST((boost::random::const_mod<IntType, 2147483563>::add(1234567890, 1234657890)) == IntType(321742217));
 }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(test_mult_add32, IntType, int32_types) {
-    BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 2147483563>::mult_add(0, 0, 0)), IntType(0));
-    BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 2147483563>::mult_add(0, 2147483562, 827364)), IntType(827364));
-    BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 2147483563>::mult_add(2147483562, 0, 827364)), IntType(827364));
-    BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 2147483563>::mult_add(2147483562, 2147483562, 2147483562)), IntType(0));
-    BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 2147483563>::mult_add(1234567890, 1234657890, 1726384759)), IntType(392007878));
+    BOOST_TEST((boost::random::const_mod<IntType, 2147483563>::mult_add(0, 0, 0)) == IntType(0));
+    BOOST_TEST((boost::random::const_mod<IntType, 2147483563>::mult_add(0, 2147483562, 827364)) == IntType(827364));
+    BOOST_TEST((boost::random::const_mod<IntType, 2147483563>::mult_add(2147483562, 0, 827364)) == IntType(827364));
+    BOOST_TEST((boost::random::const_mod<IntType, 2147483563>::mult_add(2147483562, 2147483562, 2147483562)) == IntType(0));
+    BOOST_TEST((boost::random::const_mod<IntType, 2147483563>::mult_add(1234567890, 1234657890, 1726384759)) == IntType(392007878));
 }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(test_invert32, IntType, int32_types) {
-    BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 2147483563>::invert(0)), IntType(0));
-    BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 2147483563>::mult_add(0, 0, 0)), IntType(0));
+    BOOST_TEST((boost::random::const_mod<IntType, 2147483563>::invert(0)) == IntType(0));
+    BOOST_TEST((boost::random::const_mod<IntType, 2147483563>::mult_add(0, 0, 0)) == IntType(0));
     IntType inverse;
     inverse = boost::random::const_mod<IntType, 2147483563>::invert(2147483562);
-    BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 2147483563>::mult(2147483562, inverse)), IntType(1));
+    BOOST_TEST((boost::random::const_mod<IntType, 2147483563>::mult(2147483562, inverse)) == IntType(1));
     inverse = boost::random::const_mod<IntType, 2147483563>::invert(1234567890);
-    BOOST_CHECK_EQUAL((boost::random::const_mod<IntType, 2147483563>::mult(1234567890, inverse)), IntType(1));
+    BOOST_TEST((boost::random::const_mod<IntType, 2147483563>::mult(1234567890, inverse)) == IntType(1));
 }
 
 #if !defined(BOOST_NO_INT64_T)
 
 typedef boost::mpl::vector<
-    boost::int64_t,
-    boost::uint64_t
+    std::int64_t,
+    std::uint64_t
 > int64_types;
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(test_mult64, IntType, int64_types) {
     typedef boost::random::const_mod<IntType, INT64_C(2147483563652738498)> const_mod_type;
-    BOOST_CHECK_EQUAL((const_mod_type::mult(0, 0)), IntType(0));
-    BOOST_CHECK_EQUAL((const_mod_type::mult(0, 2147483562)), IntType(0));
-    BOOST_CHECK_EQUAL((const_mod_type::mult(2147483562, 0)), IntType(0));
-    BOOST_CHECK_EQUAL((const_mod_type::mult(2147483562, 2147483562)), IntType(INT64_C(316718521754730848)));
-    BOOST_CHECK_EQUAL((const_mod_type::mult(1234567890, 1234657890)), IntType(INT64_C(1524268986129152100)));
-    BOOST_CHECK_EQUAL((const_mod_type::mult(INT64_C(1234567890726352938), INT64_C(1234657890736453927))), IntType(INT64_C(88656187017794672)));
+    BOOST_TEST((const_mod_type::mult(0, 0)) == IntType(0));
+    BOOST_TEST((const_mod_type::mult(0, 2147483562)) == IntType(0));
+    BOOST_TEST((const_mod_type::mult(2147483562, 0)) == IntType(0));
+    BOOST_TEST((const_mod_type::mult(2147483562, 2147483562)) == IntType(INT64_C(316718521754730848)));
+    BOOST_TEST((const_mod_type::mult(1234567890, 1234657890)) == IntType(INT64_C(1524268986129152100)));
+    BOOST_TEST((const_mod_type::mult(INT64_C(1234567890726352938), INT64_C(1234657890736453927))) == IntType(INT64_C(88656187017794672)));
 }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(test_add64, IntType, int64_types) {
     typedef boost::random::const_mod<IntType, INT64_C(2147483563652738498)> const_mod_type;
-    BOOST_CHECK_EQUAL((const_mod_type::add(0, 0)), IntType(0));
-    BOOST_CHECK_EQUAL((const_mod_type::add(0, 2147483562)), IntType(2147483562));
-    BOOST_CHECK_EQUAL((const_mod_type::add(2147483562, 0)), IntType(2147483562));
-    BOOST_CHECK_EQUAL((const_mod_type::add(2147483562, 2147483562)), IntType(4294967124U));
-    BOOST_CHECK_EQUAL((const_mod_type::add(1234567890, 1234657890)), IntType(2469225780U));
-    BOOST_CHECK_EQUAL((const_mod_type::add(INT64_C(1234567890726352938), INT64_C(1234657890736453927))), IntType(INT64_C(321742217810068367)));
-    BOOST_CHECK_EQUAL((const_mod_type::add(INT64_C(2147483563652738490), 8)), IntType(0));
+    BOOST_TEST((const_mod_type::add(0, 0)) == IntType(0));
+    BOOST_TEST((const_mod_type::add(0, 2147483562)) == IntType(2147483562));
+    BOOST_TEST((const_mod_type::add(2147483562, 0)) == IntType(2147483562));
+    BOOST_TEST((const_mod_type::add(2147483562, 2147483562)) == IntType(4294967124U));
+    BOOST_TEST((const_mod_type::add(1234567890, 1234657890)) == IntType(2469225780U));
+    BOOST_TEST((const_mod_type::add(INT64_C(1234567890726352938), INT64_C(1234657890736453927))) == IntType(INT64_C(321742217810068367)));
+    BOOST_TEST((const_mod_type::add(INT64_C(2147483563652738490), 8)) == IntType(0));
 }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(test_mult_add64, IntType, int64_types) {
     typedef boost::random::const_mod<IntType, INT64_C(2147483563652738498)> const_mod_type;
-    BOOST_CHECK_EQUAL((const_mod_type::mult_add(0, 0, 0)), IntType(0));
-    BOOST_CHECK_EQUAL((const_mod_type::mult_add(0, 2147483562, 827364)), IntType(827364));
-    BOOST_CHECK_EQUAL((const_mod_type::mult_add(2147483562, 0, 827364)), IntType(827364));
-    BOOST_CHECK_EQUAL((const_mod_type::mult_add(2147483562, 2147483562, 2147483562)), IntType(INT64_C(316718523902214410)));
-    BOOST_CHECK_EQUAL((const_mod_type::mult_add(1234567890, 1234657890, 1726384759)), IntType(INT64_C(1524268987855536859)));
-    BOOST_CHECK_EQUAL((const_mod_type::mult_add(INT64_C(1234567890726352938), INT64_C(1234657890736453927), INT64_C(1726384759726488649))), IntType(INT64_C(1815040946744283321)));
+    BOOST_TEST((const_mod_type::mult_add(0, 0, 0)) == IntType(0));
+    BOOST_TEST((const_mod_type::mult_add(0, 2147483562, 827364)) == IntType(827364));
+    BOOST_TEST((const_mod_type::mult_add(2147483562, 0, 827364)) == IntType(827364));
+    BOOST_TEST((const_mod_type::mult_add(2147483562, 2147483562, 2147483562)) == IntType(INT64_C(316718523902214410)));
+    BOOST_TEST((const_mod_type::mult_add(1234567890, 1234657890, 1726384759)) == IntType(INT64_C(1524268987855536859)));
+    BOOST_TEST((const_mod_type::mult_add(INT64_C(1234567890726352938), INT64_C(1234657890736453927), INT64_C(1726384759726488649))) == IntType(INT64_C(1815040946744283321)));
 }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(test_invert64, IntType, int64_types) {
     typedef boost::random::const_mod<IntType, INT64_C(2147483563652738498)> const_mod_type;
-    BOOST_CHECK_EQUAL((const_mod_type::invert(0)), IntType(0));
-    BOOST_CHECK_EQUAL((const_mod_type::mult_add(0, 0, 0)), IntType(0));
+    BOOST_TEST((const_mod_type::invert(0)) == IntType(0));
+    BOOST_TEST((const_mod_type::mult_add(0, 0, 0)) == IntType(0));
     IntType inverse;
     inverse = const_mod_type::invert(INT64_C(7362947769));
-    BOOST_CHECK_EQUAL((const_mod_type::mult(INT64_C(7362947769), inverse)), IntType(1));
+    BOOST_TEST((const_mod_type::mult(INT64_C(7362947769), inverse)) == IntType(1));
     inverse = const_mod_type::invert(INT64_C(1263142436887493875));
-    BOOST_CHECK_EQUAL((const_mod_type::mult(INT64_C(1263142436887493875), inverse)), IntType(1));
+    BOOST_TEST((const_mod_type::mult(INT64_C(1263142436887493875), inverse)) == IntType(1));
 }
 
 #endif
diff --git a/test/test_discrete_distribution.cpp b/test/test_discrete_distribution.cpp
index e14bc6430..809a65332 100644
--- a/test/test_discrete_distribution.cpp
+++ b/test/test_discrete_distribution.cpp
@@ -11,7 +11,6 @@
 
 #include <boost/random/discrete_distribution.hpp>
 #include <boost/random/linear_congruential.hpp>
-#include <boost/assign/list_of.hpp>
 #include <sstream>
 #include <vector>
 #include "concepts.hpp"
@@ -34,100 +33,96 @@ struct gen {
     }
 };
 
-#define CHECK_PROBABILITIES(actual, expected)       \
-    do {                                            \
-        std::vector<double> _actual = (actual);     \
-        std::vector<double> _expected = (expected); \
-        BOOST_CHECK_EQUAL_COLLECTIONS(              \
-            _actual.begin(), _actual.end(),         \
-            _expected.begin(), _expected.end());    \
+#define CHECK_PROBABILITIES(actual, expected)                               \
+    do {                                                                    \
+        std::vector<double> actual_ = (actual);                             \
+        std::vector<double> expected_ = make_vector<double>expected;        \
+        BOOST_TEST(actual_ == expected_, boost::test_tools::per_element()); \
     } while(false)
 
-using boost::assign::list_of;
-
 BOOST_AUTO_TEST_CASE(test_constructors) {
     boost::random::discrete_distribution<> dist;
-    CHECK_PROBABILITIES(dist.probabilities(), list_of(1.0));
+    CHECK_PROBABILITIES(dist.probabilities(), (1.0));
 
 #ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
     boost::random::discrete_distribution<> dist_il = { 1, 2, 1, 4 };
-    CHECK_PROBABILITIES(dist_il.probabilities(), list_of(.125)(.25)(.125)(.5));
+    CHECK_PROBABILITIES(dist_il.probabilities(), (.125, .25, .125, .5));
 #endif
-    std::vector<double> probs = boost::assign::list_of(1.0)(2.0)(1.0)(4.0);
+    std::vector<double> probs{ 1.0, 2.0, 1.0, 4.0 };
 
     boost::random::discrete_distribution<> dist_r(probs);
-    CHECK_PROBABILITIES(dist_r.probabilities(), list_of(.125)(.25)(.125)(.5));
+    CHECK_PROBABILITIES(dist_r.probabilities(), (.125, .25, .125, .5));
     
     boost::random::discrete_distribution<> dist_it(probs.begin(), probs.end());
-    CHECK_PROBABILITIES(dist_it.probabilities(), list_of(.125)(.25)(.125)(.5));
+    CHECK_PROBABILITIES(dist_it.probabilities(), (.125, .25, .125, .5));
     
     boost::random::discrete_distribution<> dist_fun(4, 99, 115, gen());
-    CHECK_PROBABILITIES(dist_fun.probabilities(), list_of(.125)(.25)(.125)(.5));
+    CHECK_PROBABILITIES(dist_fun.probabilities(), (.125, .25, .125, .5));
 
     boost::random::discrete_distribution<> copy(dist);
-    BOOST_CHECK_EQUAL(dist, copy);
+    BOOST_TEST(dist == copy);
     boost::random::discrete_distribution<> copy_r(dist_r);
-    BOOST_CHECK_EQUAL(dist_r, copy_r);
+    BOOST_TEST(dist_r == copy_r);
 
     boost::random::discrete_distribution<> notpow2(3, 99, 111, gen());
     BOOST_REQUIRE_EQUAL(notpow2.probabilities().size(), 3u);
-    BOOST_CHECK_CLOSE_FRACTION(notpow2.probabilities()[0], 0.25, 0.00000000001);
-    BOOST_CHECK_CLOSE_FRACTION(notpow2.probabilities()[1], 0.50, 0.00000000001);
-    BOOST_CHECK_CLOSE_FRACTION(notpow2.probabilities()[2], 0.25, 0.00000000001);
+    BOOST_TEST(notpow2.probabilities()[0] == 0.25, boost::test_tools::tolerance(0.00000000001));
+    BOOST_TEST(notpow2.probabilities()[1] == 0.50, boost::test_tools::tolerance(0.00000000001));
+    BOOST_TEST(notpow2.probabilities()[2] == 0.25, boost::test_tools::tolerance(0.00000000001));
     boost::random::discrete_distribution<> copy_notpow2(notpow2);
-    BOOST_CHECK_EQUAL(notpow2, copy_notpow2);
+    BOOST_TEST(notpow2 == copy_notpow2);
 }
 
 BOOST_AUTO_TEST_CASE(test_param) {
-    std::vector<double> probs = boost::assign::list_of(1.0)(2.0)(1.0)(4.0);
+    std::vector<double> probs{ 1.0, 2.0, 1.0, 4.0 };
     boost::random::discrete_distribution<> dist(probs);
     boost::random::discrete_distribution<>::param_type param = dist.param();
-    CHECK_PROBABILITIES(param.probabilities(), list_of(.125)(.25)(.125)(.5));
+    CHECK_PROBABILITIES(param.probabilities(), (.125, .25, .125, .5));
     boost::random::discrete_distribution<> copy1(param);
-    BOOST_CHECK_EQUAL(dist, copy1);
+    BOOST_TEST(dist == copy1);
     boost::random::discrete_distribution<> copy2;
     copy2.param(param);
-    BOOST_CHECK_EQUAL(dist, copy2);
+    BOOST_TEST(dist == copy2);
 
     boost::random::discrete_distribution<>::param_type param_copy = param;
-    BOOST_CHECK_EQUAL(param, param_copy);
+    BOOST_TEST(param == param_copy);
     BOOST_CHECK(param == param_copy);
     BOOST_CHECK(!(param != param_copy));
     boost::random::discrete_distribution<>::param_type param_default;
-    CHECK_PROBABILITIES(param_default.probabilities(), list_of(1.0));
+    CHECK_PROBABILITIES(param_default.probabilities(), (1.0));
     BOOST_CHECK(param != param_default);
     BOOST_CHECK(!(param == param_default));
     
 #ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
     boost::random::discrete_distribution<>::param_type
         parm_il = { 1, 2, 1, 4 };
-    CHECK_PROBABILITIES(parm_il.probabilities(), list_of(.125)(.25)(.125)(.5));
+    CHECK_PROBABILITIES(parm_il.probabilities(), (.125, .25, .125, .5));
 #endif
 
     boost::random::discrete_distribution<>::param_type parm_r(probs);
-    CHECK_PROBABILITIES(parm_r.probabilities(), list_of(.125)(.25)(.125)(.5));
+    CHECK_PROBABILITIES(parm_r.probabilities(), (.125, .25, .125, .5));
     
     boost::random::discrete_distribution<>::param_type
         parm_it(probs.begin(), probs.end());
-    CHECK_PROBABILITIES(parm_it.probabilities(), list_of(.125)(.25)(.125)(.5));
+    CHECK_PROBABILITIES(parm_it.probabilities(), (.125, .25, .125, .5));
     
     boost::random::discrete_distribution<>::param_type
         parm_fun(4, 99, 115, gen());
-    CHECK_PROBABILITIES(parm_fun.probabilities(), list_of(.125)(.25)(.125)(.5));
+    CHECK_PROBABILITIES(parm_fun.probabilities(), (.125, .25, .125, .5));
 }
 
 BOOST_AUTO_TEST_CASE(test_min_max) {
-    std::vector<double> probs = boost::assign::list_of(1.0)(2.0)(1.0);
+    std::vector<double> probs{ 1.0, 2.0, 1.0 };
     boost::random::discrete_distribution<> dist;
-    BOOST_CHECK_EQUAL((dist.min)(), 0);
-    BOOST_CHECK_EQUAL((dist.max)(), 0);
+    BOOST_TEST((dist.min)() == 0);
+    BOOST_TEST((dist.max)() == 0);
     boost::random::discrete_distribution<> dist_r(probs);
-    BOOST_CHECK_EQUAL((dist_r.min)(), 0);
-    BOOST_CHECK_EQUAL((dist_r.max)(), 2);
+    BOOST_TEST((dist_r.min)() == 0);
+    BOOST_TEST((dist_r.max)() == 2);
 }
 
 BOOST_AUTO_TEST_CASE(test_comparison) {
-    std::vector<double> probs = boost::assign::list_of(1.0)(2.0)(1.0)(4.0);
+    std::vector<double> probs{ 1.0, 2.0, 1.0, 4.0 };
     boost::random::discrete_distribution<> dist;
     boost::random::discrete_distribution<> dist_copy(dist);
     boost::random::discrete_distribution<> dist_r(probs);
@@ -141,28 +136,28 @@ BOOST_AUTO_TEST_CASE(test_comparison) {
 }
 
 BOOST_AUTO_TEST_CASE(test_streaming) {
-    std::vector<double> probs = boost::assign::list_of(1.0)(2.0)(1.0)(4.0);
+    std::vector<double> probs{ 1.0, 2.0, 1.0, 4.0 };
     boost::random::discrete_distribution<> dist(probs);
     std::stringstream stream;
     stream << dist;
     boost::random::discrete_distribution<> restored_dist;
     stream >> restored_dist;
-    BOOST_CHECK_EQUAL(dist, restored_dist);
+    BOOST_TEST(dist == restored_dist);
 }
 
 BOOST_AUTO_TEST_CASE(test_generation) {
-    std::vector<double> probs = boost::assign::list_of(0.0)(1.0);
+    std::vector<double> probs{ 0.0, 1.0 };
     boost::minstd_rand0 gen;
     boost::random::discrete_distribution<> dist;
     boost::random::discrete_distribution<> dist_r(probs);
     for(int i = 0; i < 10; ++i) {
         int value = dist(gen);
-        BOOST_CHECK_EQUAL(value, 0);
+        BOOST_TEST(value == 0);
         int value_r = dist_r(gen);
-        BOOST_CHECK_EQUAL(value_r, 1);
+        BOOST_TEST(value_r == 1);
         int value_param = dist_r(gen, dist.param());
-        BOOST_CHECK_EQUAL(value_param, 0);
+        BOOST_TEST(value_param == 0);
         int value_r_param = dist(gen, dist_r.param());
-        BOOST_CHECK_EQUAL(value_r_param, 1);
+        BOOST_TEST(value_r_param == 1);
     }
 }
diff --git a/test/test_distribution.ipp b/test/test_distribution.ipp
index 6699af150..7299300d7 100644
--- a/test/test_distribution.ipp
+++ b/test/test_distribution.ipp
@@ -22,46 +22,46 @@ BOOST_CONCEPT_ASSERT((RandomNumberDistribution< BOOST_RANDOM_DISTRIBUTION >));
 
 BOOST_AUTO_TEST_CASE(test_constructors) {
     BOOST_RANDOM_DISTRIBUTION dist;
-    BOOST_CHECK_EQUAL(dist.BOOST_RANDOM_ARG1(), BOOST_RANDOM_ARG1_DEFAULT);
+    BOOST_TEST(dist.BOOST_RANDOM_ARG1() == BOOST_RANDOM_ARG1_DEFAULT);
 #ifdef BOOST_RANDOM_ARG2
-    BOOST_CHECK_EQUAL(dist.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_DEFAULT);
+    BOOST_TEST(dist.BOOST_RANDOM_ARG2() == BOOST_RANDOM_ARG2_DEFAULT);
 #endif
 #ifdef BOOST_RANDOM_ARG3
-    BOOST_CHECK_EQUAL(dist.BOOST_RANDOM_ARG3(), BOOST_RANDOM_ARG3_DEFAULT);
+    BOOST_TEST(dist.BOOST_RANDOM_ARG3() == BOOST_RANDOM_ARG3_DEFAULT);
 #endif
     BOOST_RANDOM_DISTRIBUTION dist_one(BOOST_RANDOM_ARG1_VALUE);
-    BOOST_CHECK_EQUAL(dist_one.BOOST_RANDOM_ARG1(), BOOST_RANDOM_ARG1_VALUE);
+    BOOST_TEST(dist_one.BOOST_RANDOM_ARG1() == BOOST_RANDOM_ARG1_VALUE);
 #ifdef BOOST_RANDOM_ARG2
-    BOOST_CHECK_EQUAL(dist_one.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_DEFAULT);
+    BOOST_TEST(dist_one.BOOST_RANDOM_ARG2() == BOOST_RANDOM_ARG2_DEFAULT);
 #endif
 #ifdef BOOST_RANDOM_ARG3
-    BOOST_CHECK_EQUAL(dist_one.BOOST_RANDOM_ARG3(), BOOST_RANDOM_ARG3_DEFAULT);
+    BOOST_TEST(dist_one.BOOST_RANDOM_ARG3() == BOOST_RANDOM_ARG3_DEFAULT);
 #endif
 #ifdef BOOST_RANDOM_ARG2
     BOOST_RANDOM_DISTRIBUTION dist_two(BOOST_RANDOM_ARG1_VALUE, BOOST_RANDOM_ARG2_VALUE);
-    BOOST_CHECK_EQUAL(dist_two.BOOST_RANDOM_ARG1(), BOOST_RANDOM_ARG1_VALUE);
-    BOOST_CHECK_EQUAL(dist_two.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_VALUE);
+    BOOST_TEST(dist_two.BOOST_RANDOM_ARG1() == BOOST_RANDOM_ARG1_VALUE);
+    BOOST_TEST(dist_two.BOOST_RANDOM_ARG2() == BOOST_RANDOM_ARG2_VALUE);
 #ifdef BOOST_RANDOM_ARG3
-    BOOST_CHECK_EQUAL(dist_two.BOOST_RANDOM_ARG3(), BOOST_RANDOM_ARG3_DEFAULT);
+    BOOST_TEST(dist_two.BOOST_RANDOM_ARG3() == BOOST_RANDOM_ARG3_DEFAULT);
 #endif
 #endif
 #ifdef BOOST_RANDOM_ARG3
     BOOST_RANDOM_DISTRIBUTION dist_three(BOOST_RANDOM_ARG1_VALUE, BOOST_RANDOM_ARG2_VALUE, BOOST_RANDOM_ARG3_VALUE);
-    BOOST_CHECK_EQUAL(dist_three.BOOST_RANDOM_ARG1(), BOOST_RANDOM_ARG1_VALUE);
-    BOOST_CHECK_EQUAL(dist_three.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_VALUE);
-    BOOST_CHECK_EQUAL(dist_three.BOOST_RANDOM_ARG3(), BOOST_RANDOM_ARG3_VALUE);
+    BOOST_TEST(dist_three.BOOST_RANDOM_ARG1() == BOOST_RANDOM_ARG1_VALUE);
+    BOOST_TEST(dist_three.BOOST_RANDOM_ARG2() == BOOST_RANDOM_ARG2_VALUE);
+    BOOST_TEST(dist_three.BOOST_RANDOM_ARG3() == BOOST_RANDOM_ARG3_VALUE);
 #endif
     BOOST_RANDOM_DISTRIBUTION copy(dist);
-    BOOST_CHECK_EQUAL(dist, copy);
+    BOOST_TEST(dist == copy);
     BOOST_RANDOM_DISTRIBUTION copy_one(dist_one);
-    BOOST_CHECK_EQUAL(dist_one, copy_one);
+    BOOST_TEST(dist_one == copy_one);
 #ifdef BOOST_RANDOM_ARG2
     BOOST_RANDOM_DISTRIBUTION copy_two(dist_two);
-    BOOST_CHECK_EQUAL(dist_two, copy_two);
+    BOOST_TEST(dist_two == copy_two);
 #endif
 #ifdef BOOST_RANDOM_ARG3
     BOOST_RANDOM_DISTRIBUTION copy_three(dist_three);
-    BOOST_CHECK_EQUAL(dist_three, copy_three);
+    BOOST_TEST(dist_three == copy_three);
 #endif
 }
 
@@ -74,40 +74,40 @@ BOOST_AUTO_TEST_CASE(test_param) {
     BOOST_RANDOM_DISTRIBUTION dist(BOOST_RANDOM_ARG1_VALUE);
 #endif
     BOOST_RANDOM_DISTRIBUTION::param_type param = dist.param();
-    BOOST_CHECK_EQUAL(param.BOOST_RANDOM_ARG1(), BOOST_RANDOM_ARG1_VALUE);
+    BOOST_TEST(param.BOOST_RANDOM_ARG1() == BOOST_RANDOM_ARG1_VALUE);
 #ifdef BOOST_RANDOM_ARG2
-    BOOST_CHECK_EQUAL(param.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_VALUE);
+    BOOST_TEST(param.BOOST_RANDOM_ARG2() == BOOST_RANDOM_ARG2_VALUE);
 #endif
 #ifdef BOOST_RANDOM_ARG3
-    BOOST_CHECK_EQUAL(param.BOOST_RANDOM_ARG3(), BOOST_RANDOM_ARG3_VALUE);
+    BOOST_TEST(param.BOOST_RANDOM_ARG3() == BOOST_RANDOM_ARG3_VALUE);
 #endif
     BOOST_RANDOM_DISTRIBUTION copy1(param);
-    BOOST_CHECK_EQUAL(dist, copy1);
+    BOOST_TEST(dist == copy1);
     BOOST_RANDOM_DISTRIBUTION copy2;
     copy2.param(param);
-    BOOST_CHECK_EQUAL(dist, copy2);
+    BOOST_TEST(dist == copy2);
 
     BOOST_RANDOM_DISTRIBUTION::param_type param_copy = param;
-    BOOST_CHECK_EQUAL(param, param_copy);
+    BOOST_TEST(param == param_copy);
     BOOST_CHECK(param == param_copy);
     BOOST_CHECK(!(param != param_copy));
     BOOST_RANDOM_DISTRIBUTION::param_type param_default;
-    BOOST_CHECK_EQUAL(param_default.BOOST_RANDOM_ARG1(), BOOST_RANDOM_ARG1_DEFAULT);
+    BOOST_TEST(param_default.BOOST_RANDOM_ARG1() == BOOST_RANDOM_ARG1_DEFAULT);
 #ifdef BOOST_RANDOM_ARG2
-    BOOST_CHECK_EQUAL(param_default.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_DEFAULT);
+    BOOST_TEST(param_default.BOOST_RANDOM_ARG2() == BOOST_RANDOM_ARG2_DEFAULT);
 #endif
 #ifdef BOOST_RANDOM_ARG3
-    BOOST_CHECK_EQUAL(param_default.BOOST_RANDOM_ARG3(), BOOST_RANDOM_ARG3_DEFAULT);
+    BOOST_TEST(param_default.BOOST_RANDOM_ARG3() == BOOST_RANDOM_ARG3_DEFAULT);
 #endif
     BOOST_CHECK(param != param_default);
     BOOST_CHECK(!(param == param_default));
     BOOST_RANDOM_DISTRIBUTION::param_type param_one(BOOST_RANDOM_ARG1_VALUE);
-    BOOST_CHECK_EQUAL(param_one.BOOST_RANDOM_ARG1(), BOOST_RANDOM_ARG1_VALUE);
+    BOOST_TEST(param_one.BOOST_RANDOM_ARG1() == BOOST_RANDOM_ARG1_VALUE);
 #ifdef BOOST_RANDOM_ARG2
-    BOOST_CHECK_EQUAL(param_one.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_DEFAULT);
+    BOOST_TEST(param_one.BOOST_RANDOM_ARG2() == BOOST_RANDOM_ARG2_DEFAULT);
 #endif
 #ifdef BOOST_RANDOM_ARG3
-    BOOST_CHECK_EQUAL(param_one.BOOST_RANDOM_ARG3(), BOOST_RANDOM_ARG3_DEFAULT);
+    BOOST_TEST(param_one.BOOST_RANDOM_ARG3() == BOOST_RANDOM_ARG3_DEFAULT);
 #endif
 #ifdef BOOST_RANDOM_ARG2
     BOOST_CHECK(param != param_one);
@@ -117,36 +117,36 @@ BOOST_AUTO_TEST_CASE(test_param) {
     BOOST_CHECK(!(param_default == param_one));
 #ifdef BOOST_RANDOM_ARG2
     BOOST_RANDOM_DISTRIBUTION::param_type param_two(BOOST_RANDOM_ARG1_VALUE, BOOST_RANDOM_ARG2_VALUE);
-    BOOST_CHECK_EQUAL(param_two.BOOST_RANDOM_ARG1(), BOOST_RANDOM_ARG1_VALUE);
-    BOOST_CHECK_EQUAL(param_two.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_VALUE);
+    BOOST_TEST(param_two.BOOST_RANDOM_ARG1() == BOOST_RANDOM_ARG1_VALUE);
+    BOOST_TEST(param_two.BOOST_RANDOM_ARG2() == BOOST_RANDOM_ARG2_VALUE);
 #ifdef BOOST_RANDOM_ARG3
-    BOOST_CHECK_EQUAL(param_two.BOOST_RANDOM_ARG3(), BOOST_RANDOM_ARG3_DEFAULT);
+    BOOST_TEST(param_two.BOOST_RANDOM_ARG3() == BOOST_RANDOM_ARG3_DEFAULT);
 #endif
 #endif
 #ifdef BOOST_RANDOM_ARG3
     BOOST_RANDOM_DISTRIBUTION::param_type param_three(BOOST_RANDOM_ARG1_VALUE, BOOST_RANDOM_ARG2_VALUE, BOOST_RANDOM_ARG3_VALUE);
-    BOOST_CHECK_EQUAL(param_three.BOOST_RANDOM_ARG1(), BOOST_RANDOM_ARG1_VALUE);
-    BOOST_CHECK_EQUAL(param_three.BOOST_RANDOM_ARG2(), BOOST_RANDOM_ARG2_VALUE);
-    BOOST_CHECK_EQUAL(param_three.BOOST_RANDOM_ARG3(), BOOST_RANDOM_ARG3_VALUE);
+    BOOST_TEST(param_three.BOOST_RANDOM_ARG1() == BOOST_RANDOM_ARG1_VALUE);
+    BOOST_TEST(param_three.BOOST_RANDOM_ARG2() == BOOST_RANDOM_ARG2_VALUE);
+    BOOST_TEST(param_three.BOOST_RANDOM_ARG3() == BOOST_RANDOM_ARG3_VALUE);
 #endif
 }
 
 BOOST_AUTO_TEST_CASE(test_min_max) {
     BOOST_RANDOM_DISTRIBUTION dist;
-    BOOST_CHECK_EQUAL((dist.min)(), BOOST_RANDOM_DIST0_MIN);
-    BOOST_CHECK_EQUAL((dist.max)(), BOOST_RANDOM_DIST0_MAX);
+    BOOST_TEST((dist.min)() == BOOST_RANDOM_DIST0_MIN);
+    BOOST_TEST((dist.max)() == BOOST_RANDOM_DIST0_MAX);
     BOOST_RANDOM_DISTRIBUTION dist_one(BOOST_RANDOM_ARG1_VALUE);
-    BOOST_CHECK_EQUAL((dist_one.min)(), BOOST_RANDOM_DIST1_MIN);
-    BOOST_CHECK_EQUAL((dist_one.max)(), BOOST_RANDOM_DIST1_MAX);
+    BOOST_TEST((dist_one.min)() == BOOST_RANDOM_DIST1_MIN);
+    BOOST_TEST((dist_one.max)() == BOOST_RANDOM_DIST1_MAX);
 #ifdef BOOST_RANDOM_ARG2
     BOOST_RANDOM_DISTRIBUTION dist_two(BOOST_RANDOM_ARG1_VALUE, BOOST_RANDOM_ARG2_VALUE);
-    BOOST_CHECK_EQUAL((dist_two.min)(), BOOST_RANDOM_DIST2_MIN);
-    BOOST_CHECK_EQUAL((dist_two.max)(), BOOST_RANDOM_DIST2_MAX);
+    BOOST_TEST((dist_two.min)() == BOOST_RANDOM_DIST2_MIN);
+    BOOST_TEST((dist_two.max)() == BOOST_RANDOM_DIST2_MAX);
 #endif
 #ifdef BOOST_RANDOM_ARG3
     BOOST_RANDOM_DISTRIBUTION dist_three(BOOST_RANDOM_ARG1_VALUE, BOOST_RANDOM_ARG2_VALUE, BOOST_RANDOM_ARG3_VALUE);
-    BOOST_CHECK_EQUAL((dist_three.min)(), BOOST_RANDOM_DIST3_MIN);
-    BOOST_CHECK_EQUAL((dist_three.max)(), BOOST_RANDOM_DIST3_MAX);
+    BOOST_TEST((dist_three.min)() == BOOST_RANDOM_DIST3_MIN);
+    BOOST_TEST((dist_three.max)() == BOOST_RANDOM_DIST3_MAX);
 #endif
 }
 
@@ -201,7 +201,7 @@ BOOST_AUTO_TEST_CASE(test_streaming) {
     stream << dist;
     BOOST_RANDOM_DISTRIBUTION restored_dist;
     stream >> restored_dist;
-    BOOST_CHECK_EQUAL(dist, restored_dist);
+    BOOST_TEST(dist == restored_dist);
 }
 
 void use(BOOST_RANDOM_DISTRIBUTION::result_type) {}
@@ -218,54 +218,54 @@ BOOST_AUTO_TEST_CASE(test_generation) {
         result_type value = dist(gen);
         use(value);
 #ifdef BOOST_RANDOM_TEST1_MIN
-        BOOST_CHECK_GE(value, BOOST_RANDOM_TEST1_MIN);
+        BOOST_TEST(value >= BOOST_RANDOM_TEST1_MIN);
 #endif
 #ifdef BOOST_RANDOM_TEST1_MAX
-        BOOST_CHECK_LE(value, BOOST_RANDOM_TEST1_MAX);
+        BOOST_TEST(value <= BOOST_RANDOM_TEST1_MAX);
 #endif
         result_type value_two = dist_two(gen);
         use(value_two);
 #ifdef BOOST_RANDOM_TEST2_MIN
-        BOOST_CHECK_GE(value_two, BOOST_RANDOM_TEST2_MIN);
+        BOOST_TEST(value_two >= BOOST_RANDOM_TEST2_MIN);
 #endif
 #ifdef BOOST_RANDOM_TEST2_MAX
-        BOOST_CHECK_LE(value_two, BOOST_RANDOM_TEST2_MAX);
+        BOOST_TEST(value_two <= BOOST_RANDOM_TEST2_MAX);
 #endif
 #ifdef BOOST_RANDOM_TEST3_PARAMS
     	result_type value_three = dist_three(gen);
     	use(value_three);
 #endif
 #ifdef BOOST_RANDOM_TEST3_MIN
-        BOOST_CHECK_GE(value_three, BOOST_RANDOM_TEST3_MIN);
+        BOOST_TEST(value_three >= BOOST_RANDOM_TEST3_MIN);
 #endif
 #ifdef BOOST_RANDOM_TEST3_MAX
-        BOOST_CHECK_LE(value_three, BOOST_RANDOM_TEST3_MAX);
+        BOOST_TEST(value_three <= BOOST_RANDOM_TEST3_MAX);
 #endif
         result_type value_param = dist_two(gen, dist.param());
         use(value_param);
 #ifdef BOOST_RANDOM_TEST1_MIN
-        BOOST_CHECK_GE(value_param, BOOST_RANDOM_TEST1_MIN);
+        BOOST_TEST(value_param >= BOOST_RANDOM_TEST1_MIN);
 #endif
 #ifdef BOOST_RANDOM_TEST1_MAX
-        BOOST_CHECK_LE(value_param, BOOST_RANDOM_TEST1_MAX);
+        BOOST_TEST(value_param <= BOOST_RANDOM_TEST1_MAX);
 #endif
         result_type value_two_param = dist(gen, dist_two.param());
         use(value_two_param);
 #ifdef BOOST_RANDOM_TEST2_MIN
-        BOOST_CHECK_GE(value_two_param, BOOST_RANDOM_TEST2_MIN);
+        BOOST_TEST(value_two_param >= BOOST_RANDOM_TEST2_MIN);
 #endif
 #ifdef BOOST_RANDOM_TEST2_MAX
-        BOOST_CHECK_LE(value_two_param, BOOST_RANDOM_TEST2_MAX);
+        BOOST_TEST(value_two_param <= BOOST_RANDOM_TEST2_MAX);
 #endif
 #ifdef BOOST_RANDOM_TEST3_PARAMS
     	result_type value_three_param = dist(gen, dist_three.param());
         use(value_three_param);
 #endif
 #ifdef BOOST_RANDOM_TEST3_MIN
-        BOOST_CHECK_GE(value_three_param, BOOST_RANDOM_TEST3_MIN);
+        BOOST_TEST(value_three_param >= BOOST_RANDOM_TEST3_MIN);
 #endif
 #ifdef BOOST_RANDOM_TEST3_MAX
-        BOOST_CHECK_LE(value_three_param, BOOST_RANDOM_TEST3_MAX);
+        BOOST_TEST(value_three_param <= BOOST_RANDOM_TEST3_MAX);
 #endif
     }
 }
@@ -279,34 +279,34 @@ BOOST_AUTO_TEST_CASE(test_generation_float) {
         result_type value = dist(gen);
         use(value);
 #ifdef BOOST_RANDOM_TEST1_MIN
-        BOOST_CHECK_GE(value, BOOST_RANDOM_TEST1_MIN);
+        BOOST_TEST(value >= BOOST_RANDOM_TEST1_MIN);
 #endif
 #ifdef BOOST_RANDOM_TEST1_MAX
-        BOOST_CHECK_LE(value, BOOST_RANDOM_TEST1_MAX);
+        BOOST_TEST(value <= BOOST_RANDOM_TEST1_MAX);
 #endif
         result_type value_two = dist_two(gen);
         use(value_two);
 #ifdef BOOST_RANDOM_TEST2_MIN
-        BOOST_CHECK_GE(value_two, BOOST_RANDOM_TEST2_MIN);
+        BOOST_TEST(value_two >= BOOST_RANDOM_TEST2_MIN);
 #endif
 #ifdef BOOST_RANDOM_TEST2_MAX
-        BOOST_CHECK_LE(value_two, BOOST_RANDOM_TEST2_MAX);
+        BOOST_TEST(value_two <= BOOST_RANDOM_TEST2_MAX);
 #endif
         result_type value_param = dist_two(gen, dist.param());
         use(value_param);
 #ifdef BOOST_RANDOM_TEST1_MIN
-        BOOST_CHECK_GE(value_param, BOOST_RANDOM_TEST1_MIN);
+        BOOST_TEST(value_param >= BOOST_RANDOM_TEST1_MIN);
 #endif
 #ifdef BOOST_RANDOM_TEST1_MAX
-        BOOST_CHECK_LE(value_param, BOOST_RANDOM_TEST1_MAX);
+        BOOST_TEST(value_param <= BOOST_RANDOM_TEST1_MAX);
 #endif
         result_type value_two_param = dist(gen, dist_two.param());
         use(value_two_param);
 #ifdef BOOST_RANDOM_TEST2_MIN
-        BOOST_CHECK_GE(value_two_param, BOOST_RANDOM_TEST2_MIN);
+        BOOST_TEST(value_two_param >= BOOST_RANDOM_TEST2_MIN);
 #endif
 #ifdef BOOST_RANDOM_TEST2_MAX
-        BOOST_CHECK_LE(value_two_param, BOOST_RANDOM_TEST2_MAX);
+        BOOST_TEST(value_two_param <= BOOST_RANDOM_TEST2_MAX);
 #endif
     }
 }
diff --git a/test/test_generate_canonical.cpp b/test/test_generate_canonical.cpp
index cc45f8a9e..ff1ac266a 100644
--- a/test/test_generate_canonical.cpp
+++ b/test/test_generate_canonical.cpp
@@ -14,7 +14,7 @@
 #include <boost/random/linear_congruential.hpp>
 #include <boost/random/mersenne_twister.hpp>
 #include <boost/random/lagged_fibonacci.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
 #include <boost/mpl/vector.hpp>
 
 #define BOOST_TEST_MAIN
@@ -32,18 +32,18 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_float, Engine, engines)
     Engine expected;
     for(int i = 0; i < 1000; ++i) {
         float val = boost::random::generate_canonical<float, 64>(eng);
-        BOOST_CHECK_GE(val, 0);
-        BOOST_CHECK_LT(val, 1);
+        BOOST_TEST(val >= 0.f);
+        BOOST_TEST(val < 1.f);
     }
     expected.discard(1000);
-    BOOST_CHECK_EQUAL(eng, expected);
+    BOOST_TEST(eng == expected);
     for(int i = 0; i < 1000; ++i) {
         float val = boost::random::generate_canonical<float, 12>(eng);
-        BOOST_CHECK_GE(val, 0);
-        BOOST_CHECK_LT(val, 1);
+        BOOST_TEST(val >= 0.f);
+        BOOST_TEST(val < 1.f);
     }
     expected.discard(1000);
-    BOOST_CHECK_EQUAL(eng, expected);
+    BOOST_TEST(eng == expected);
 }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(test_double, Engine, engines)
@@ -52,18 +52,18 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_double, Engine, engines)
     Engine expected;
     for(int i = 0; i < 1000; ++i) {
         double val = boost::random::generate_canonical<double, 64>(eng);
-        BOOST_CHECK_GE(val, 0);
-        BOOST_CHECK_LT(val, 1);
+        BOOST_TEST(val >= 0);
+        BOOST_TEST(val < 1);
     }
     expected.discard(2000);
-    BOOST_CHECK_EQUAL(eng, expected);
+    BOOST_TEST(eng == expected);
     for(int i = 0; i < 1000; ++i) {
         double val = boost::random::generate_canonical<double, 12>(eng);
-        BOOST_CHECK_GE(val, 0);
-        BOOST_CHECK_LT(val, 1);
+        BOOST_TEST(val >= 0);
+        BOOST_TEST(val < 1);
     }
     expected.discard(1000);
-    BOOST_CHECK_EQUAL(eng, expected);
+    BOOST_TEST(eng == expected);
 }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(test_long_double, Engine, engines)
@@ -72,33 +72,33 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_long_double, Engine, engines)
     Engine expected;
     for(int i = 0; i < 1000; ++i) {
         long double val = boost::random::generate_canonical<long double, 60>(eng);
-        BOOST_CHECK_GE(val, 0);
-        BOOST_CHECK_LT(val, 1);
+        BOOST_TEST(val >= 0);
+        BOOST_TEST(val < 1);
     }
     expected.discard(2000);
-    BOOST_CHECK_EQUAL(eng, expected);
+    BOOST_TEST(eng == expected);
     for(int i = 0; i < 1000; ++i) {
         long double val = boost::random::generate_canonical<long double, 12>(eng);
-        BOOST_CHECK_GE(val, 0);
-        BOOST_CHECK_LT(val, 1);
+        BOOST_TEST(val >= 0);
+        BOOST_TEST(val < 1);
     }
     expected.discard(1000);
-    BOOST_CHECK_EQUAL(eng, expected);
+    BOOST_TEST(eng == expected);
 }
 
 struct max_engine
 {
-    typedef boost::uint32_t result_type;
+    typedef std::uint32_t result_type;
     static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { return 0; }
     static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return ~boost::uint32_t(0); }
+    { return ~std::uint32_t(0); }
     result_type operator()() { return (max)(); }
 };
 
 BOOST_AUTO_TEST_CASE(test_max)
 {
     max_engine eng;
-    BOOST_CHECK_LT((boost::random::generate_canonical<float, 64>(eng)), 1);
-    BOOST_CHECK_LT((boost::random::generate_canonical<double, 64>(eng)), 1);
-    BOOST_CHECK_LT((boost::random::generate_canonical<long double, 64>(eng)), 1);
+    BOOST_TEST((boost::random::generate_canonical<float, 64>(eng)) < 1.f);
+    BOOST_TEST((boost::random::generate_canonical<double, 64>(eng)) < 1.);
+    BOOST_TEST((boost::random::generate_canonical<long double, 64>(eng)) < 1.);
 }
diff --git a/test/test_generator.ipp b/test/test_generator.ipp
index c8dc911c0..3fd5877ed 100644
--- a/test/test_generator.ipp
+++ b/test/test_generator.ipp
@@ -9,6 +9,7 @@
  *
  */
 
+#include <cstdint>
 #include "concepts.hpp"
 #include <boost/random/seed_seq.hpp>
 #include <boost/random/detail/seed.hpp>
@@ -73,7 +74,7 @@ void test_seed(seed_type value)
     test_seed_conversion<unsigned long>(urng, value);
 #if !defined(BOOST_NO_INT64_T)
     test_seed_conversion<boost::int64_t>(urng, value);
-    test_seed_conversion<boost::uint64_t>(urng, value);
+    test_seed_conversion<std::uint64_t>(urng, value);
 #endif
 
     // floating point types
@@ -87,9 +88,9 @@ BOOST_AUTO_TEST_CASE(test_default_seed)
     BOOST_RANDOM_URNG urng;
     BOOST_RANDOM_URNG urng2;
     urng2();
-    BOOST_CHECK_NE(urng, urng2);
+    BOOST_TEST(urng != urng2);
     urng2.seed();
-    BOOST_CHECK_EQUAL(urng, urng2);
+    BOOST_TEST(urng == urng2);
 }
 
 BOOST_AUTO_TEST_CASE(test_arithmetic_seed)
@@ -109,15 +110,15 @@ BOOST_AUTO_TEST_CASE(test_iterator_seed)
     BOOST_RANDOM_URNG urng(it, it_end);
     BOOST_CHECK(it != v.begin());
     std::iterator_traits<std::vector<int>::const_iterator>::difference_type n_words = (it - v.begin());
-    BOOST_CHECK_GT(n_words, 0);
-    BOOST_CHECK_EQUAL(n_words, BOOST_RANDOM_SEED_WORDS);
+    BOOST_TEST(n_words > 0);
+    BOOST_TEST(n_words == BOOST_RANDOM_SEED_WORDS);
 
     it = v.begin();
     BOOST_RANDOM_URNG urng2;
     urng2.seed(it, it_end);
     std::iterator_traits<std::vector<int>::const_iterator>::difference_type n_words2 = (it - v.begin());
-    BOOST_CHECK_EQUAL(n_words, n_words2);
-    BOOST_CHECK_EQUAL(urng, urng2);
+    BOOST_TEST(n_words == n_words2);
+    BOOST_TEST(urng == urng2);
 
     it = v.end();
     BOOST_CHECK_THROW(BOOST_RANDOM_URNG(it, it_end), std::invalid_argument);
@@ -139,9 +140,9 @@ BOOST_AUTO_TEST_CASE(test_seed_seq_seed)
     boost::random::seed_seq q;
     BOOST_RANDOM_URNG urng(q);
     BOOST_RANDOM_URNG urng2;
-    BOOST_CHECK_NE(urng, urng2);
+    BOOST_TEST(urng != urng2);
     urng2.seed(q);
-    BOOST_CHECK_EQUAL(urng, urng2);
+    BOOST_TEST(urng == urng2);
 }
 
 template<class CharT>
@@ -149,12 +150,13 @@ void do_test_streaming(const BOOST_RANDOM_URNG& urng)
 {
     BOOST_RANDOM_URNG urng2;
     std::basic_ostringstream<CharT> output;
-    output << urng;
-    BOOST_CHECK_NE(urng, urng2);
+    BOOST_TEST_REQUIRE(static_cast<bool>(output << urng));
+    BOOST_TEST(urng != urng2);
     // restore old state
     std::basic_istringstream<CharT> input(output.str());
-    input >> urng2;
-    BOOST_CHECK_EQUAL(urng, urng2);
+    BOOST_TEST(static_cast<bool>(input >> urng2));
+    BOOST_TEST(input.eof());
+    BOOST_TEST(urng == urng2);
 }
 
 BOOST_AUTO_TEST_CASE(test_streaming)
@@ -171,12 +173,12 @@ BOOST_AUTO_TEST_CASE(test_discard)
 {
     BOOST_RANDOM_URNG urng;
     BOOST_RANDOM_URNG urng2;
-    BOOST_CHECK_EQUAL(urng, urng2);
+    BOOST_TEST(urng == urng2);
     for(int i = 0; i < BOOST_RANDOM_DISCARD_COUNT1; ++i)
         urng();
-    BOOST_CHECK_NE(urng, urng2);
+    BOOST_TEST(urng != urng2);
     urng2.discard(BOOST_RANDOM_DISCARD_COUNT1);
-    BOOST_CHECK_EQUAL(urng, urng2);
+    BOOST_TEST(urng == urng2);
 }
 
 #ifdef BOOST_RANDOM_DISCARD_COUNT2
@@ -184,27 +186,27 @@ BOOST_AUTO_TEST_CASE(test_discard2)
 {
     BOOST_RANDOM_URNG urng;
     BOOST_RANDOM_URNG urng2;
-    BOOST_CHECK_EQUAL(urng, urng2);
+    BOOST_TEST(urng == urng2);
     for(int i = 0; i < BOOST_RANDOM_DISCARD_COUNT2; ++i)
         urng();
-    BOOST_CHECK_NE(urng, urng2);
+    BOOST_TEST(urng != urng2);
     urng2.discard(BOOST_RANDOM_DISCARD_COUNT2);
-    BOOST_CHECK_EQUAL(urng, urng2);
+    BOOST_TEST(urng == urng2);
 }
 #endif
 
 #ifdef BOOST_RANDOM_DISCARD_MAX
 BOOST_AUTO_TEST_CASE(test_discard_max)
 {
-    boost::uintmax_t val = (std::numeric_limits<boost::uintmax_t>::max)();
-    boost::uintmax_t half = val / 2;
+    std::uintmax_t val = (std::numeric_limits<std::uintmax_t>::max)();
+    std::uintmax_t half = val / 2;
     BOOST_RANDOM_URNG urng;
     BOOST_RANDOM_URNG urng2;
     urng.discard(half);
     urng.discard(half);
     urng.discard(val - 2*half);
     urng2.discard(val);
-    BOOST_CHECK_EQUAL(urng, urng2);
+    BOOST_TEST(urng == urng2);
 }
 #endif
 
@@ -214,16 +216,16 @@ BOOST_AUTO_TEST_CASE(test_copy)
     urng.discard(9307);
     {
         BOOST_RANDOM_URNG urng2 = urng;
-        BOOST_CHECK_EQUAL(urng, urng2);
+        BOOST_TEST(urng == urng2);
     }
     {
         BOOST_RANDOM_URNG urng2(urng);
-        BOOST_CHECK_EQUAL(urng, urng2);
+        BOOST_TEST(urng == urng2);
     }
     {
         BOOST_RANDOM_URNG urng2;
         urng2 = urng;
-        BOOST_CHECK_EQUAL(urng, urng2);
+        BOOST_TEST(urng == urng2);
     }
 }
 
@@ -232,8 +234,8 @@ BOOST_AUTO_TEST_CASE(test_min_max)
     BOOST_RANDOM_URNG urng;
     for(int i = 0; i < 10000; ++i) {
         result_type value = urng();
-        BOOST_CHECK_GE(value, (BOOST_RANDOM_URNG::min)());
-        BOOST_CHECK_LE(value, (BOOST_RANDOM_URNG::max)());
+        BOOST_TEST(value >= (BOOST_RANDOM_URNG::min)());
+        BOOST_TEST(value <= (BOOST_RANDOM_URNG::max)());
     }
 }
 
@@ -259,7 +261,7 @@ BOOST_AUTO_TEST_CASE(validate)
     for(int i = 0; i < 9999; ++i) {
         urng();
     }
-    BOOST_CHECK_EQUAL(urng(), BOOST_RANDOM_VALIDATION_VALUE);
+    BOOST_TEST(urng() == BOOST_RANDOM_VALIDATION_VALUE);
 }
 
 BOOST_AUTO_TEST_CASE(validate_seed_seq)
@@ -269,7 +271,7 @@ BOOST_AUTO_TEST_CASE(validate_seed_seq)
     for(int i = 0; i < 9999; ++i) {
         urng();
     }
-    BOOST_CHECK_EQUAL(urng(), BOOST_RANDOM_SEED_SEQ_VALIDATION_VALUE);
+    BOOST_TEST(urng() == BOOST_RANDOM_SEED_SEQ_VALIDATION_VALUE);
 }
 
 #if 0
@@ -282,15 +284,15 @@ BOOST_AUTO_TEST_CASE(validate_iter)
     for(int i = 0; i < 9999; ++i) {
         urng();
     }
-    BOOST_CHECK_EQUAL(urng(), BOOST_RANDOM_ITERATOR_VALIDATION_VALUE);
+    BOOST_TEST(urng() == BOOST_RANDOM_ITERATOR_VALIDATION_VALUE);
 }
 
 BOOST_AUTO_TEST_CASE(test_generate)
 {
     BOOST_RANDOM_URNG urng;
-    boost::uint32_t expected[] = BOOST_RANDOM_GENERATE_VALUES;
+    std::uint32_t expected[] = BOOST_RANDOM_GENERATE_VALUES;
     static const std::size_t N = sizeof(expected)/sizeof(expected[0]); 
-    boost::uint32_t actual[N];
+    std::uint32_t actual[N];
     urng.generate(&actual[0], &actual[0] + N);
     BOOST_CHECK_EQUAL_COLLECTIONS(actual, actual + N, expected, expected + N);
 }
diff --git a/test/test_geometric_distribution.cpp b/test/test_geometric_distribution.cpp
index bb54d0259..e3228d76b 100644
--- a/test/test_geometric_distribution.cpp
+++ b/test/test_geometric_distribution.cpp
@@ -10,6 +10,7 @@
  */
 
 #include <boost/random/geometric_distribution.hpp>
+#include <limits>
 
 #define BOOST_RANDOM_DISTRIBUTION boost::random::geometric_distribution<>
 #define BOOST_RANDOM_ARG1 p
diff --git a/test/test_hyperexponential_distribution.cpp b/test/test_hyperexponential_distribution.cpp
index 81c0b6987..564143de5 100644
--- a/test/test_hyperexponential_distribution.cpp
+++ b/test/test_hyperexponential_distribution.cpp
@@ -12,7 +12,6 @@
 #include <boost/random/hyperexponential_distribution.hpp>
 #include <boost/random/linear_congruential.hpp>
 #include <boost/random/lagged_fibonacci.hpp>
-#include <boost/assign/list_of.hpp>
 #include <limits>
 #include <sstream>
 #include <vector>
@@ -23,11 +22,11 @@
 #include <boost/test/unit_test.hpp>
 
 
-#define BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(T, actual, expected, tol)\
+#define BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(actual, expected, tol)   \
     do {                                                                       \
-        std::vector<T> x = (actual);                                           \
-        std::vector<T> y = (expected);                                         \
-        BOOST_CHECK_EQUAL( x.size(), y.size() );                               \
+        const std::vector<double>& x = (actual);                               \
+        const std::vector<double>& y = expected;                               \
+        BOOST_TEST( x.size() == y.size() );                               \
         const std::size_t n = x.size();                                        \
         for (std::size_t i = 0; i < n; ++i)                                    \
         {                                                                      \
@@ -42,7 +41,7 @@ namespace /*<unnamed>*/ { namespace detail {
 template <typename RealT>
 RealT make_tolerance()
 {
-    // Tolerance is 100eps expressed as a percentage (as required by Boost.Build):
+    // Tolerance is 100eps expressed as a percentage (as required by Boost.Test):
     return boost::math::tools::epsilon<RealT>() * 100 * 100;
 }
 
@@ -57,135 +56,135 @@ BOOST_AUTO_TEST_CASE( test_constructors )
 
     // Test default ctor
     boost::random::hyperexponential_distribution<> dist;
-    BOOST_CHECK_EQUAL(dist.num_phases(), 1u);
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist.probabilities(), boost::assign::list_of(1.0), tol);
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist.rates(), boost::assign::list_of(1.0), tol);
+    BOOST_TEST(dist.num_phases() == 1u);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist.probabilities(), std::vector<double>{1.0}, tol);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist.rates(), std::vector<double>{1.0}, tol);
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) && !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
     // Test ctor from initializer_list with probabilities and rates
     boost::random::hyperexponential_distribution<> dist_il_p_r = {{1, 2, 3, 4 }, {1, 2, 3, 4}};
-    BOOST_CHECK_EQUAL(dist_il_p_r.num_phases(), 4u);
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_il_p_r.probabilities(), boost::assign::list_of(.1)(.2)(.3)(.4), tol);
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_il_p_r.rates(), boost::assign::list_of(1.)(2.)(3.)(4.), tol);
+    BOOST_TEST(dist_il_p_r.num_phases() == 4u);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_il_p_r.probabilities(), make_vector(.1, .2, .3, .4), tol);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_il_p_r.rates(), make_vector(1., 2., 3., 4.), tol);
 
     // Test ctor from initializer_list with rates
     boost::random::hyperexponential_distribution<> dist_il_r = {{1, 2, 3, 4}};
-    BOOST_CHECK_EQUAL(dist_il_r.num_phases(), 4u);
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_il_r.probabilities(), boost::assign::list_of(.25)(.25)(.25)(.25), tol);
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_il_r.rates(), boost::assign::list_of(1.)(2.)(3.)(4.), tol);
+    BOOST_TEST(dist_il_r.num_phases() == 4u);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_il_r.probabilities(), make_vector(.25, .25, .25, .25), tol);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_il_r.rates(), make_vector(1., 2., 3., 4.), tol);
 #endif
 
-    const std::vector<double> probs = boost::assign::list_of(0.1)(0.2)(0.3)(0.4);
-    const std::vector<double> rates = boost::assign::list_of(1.0)(2.0)(3.0)(4.0);
+    const std::vector<double> probs{ 0.1, 0.2, 0.3, 0.4 };
+    const std::vector<double> rates{ 1.0, 2.0, 3.0, 4.0 };
 
     // Test ctor from range
     boost::random::hyperexponential_distribution<> dist_r(probs, rates);
-    BOOST_CHECK_EQUAL(dist_r.num_phases(), 4u);
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_r.probabilities(), probs, tol);
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_r.rates(), rates, tol);
+    BOOST_TEST(dist_r.num_phases() == 4u);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_r.probabilities(), probs, tol);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_r.rates(), rates, tol);
 
     // Test ctor from iterators
     boost::random::hyperexponential_distribution<> dist_it(probs.begin(), probs.end(), rates.begin(), rates.end());
-    BOOST_CHECK_EQUAL(dist_it.num_phases(), 4u);
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_it.probabilities(), probs, tol);
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_it.rates(), rates, tol);
+    BOOST_TEST(dist_it.num_phases() == 4u);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_it.probabilities(), probs, tol);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_it.rates(), rates, tol);
 
     // Test ctor from rate iterators
     boost::random::hyperexponential_distribution<> dist_r_it(rates.begin(), rates.end());
-    BOOST_CHECK_EQUAL(dist_r_it.num_phases(), 4u);
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_r_it.probabilities(), boost::assign::list_of(.25)(.25)(.25)(.25), tol);
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_r_it.rates(), rates, tol);
+    BOOST_TEST(dist_r_it.num_phases() == 4u);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_r_it.probabilities(), make_vector(.25, .25, .25, .25), tol);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_r_it.rates(), rates, tol);
 
     // Test ctor from rate iterators #2
 	{
         const double rates2[] = {1.0,2.0,3.0,4.0};
         boost::random::hyperexponential_distribution<> dist_r_it(rates2, rates2+4);
-        BOOST_CHECK_EQUAL(dist_r_it.num_phases(), 4u);
-        BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_r_it.probabilities(), boost::assign::list_of(.25)(.25)(.25)(.25), tol);
-        BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_r_it.rates(), std::vector<double>(rates2, rates2+4), tol);
+        BOOST_TEST(dist_r_it.num_phases() == 4u);
+        BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_r_it.probabilities(), make_vector(.25, .25, .25, .25), tol);
+        BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_r_it.rates(), std::vector<double>(rates2, rates2+4), tol);
     }
 
     // Test ctor from rate range
     boost::random::hyperexponential_distribution<> dist_r_r(rates);
-    BOOST_CHECK_EQUAL(dist_r_r.num_phases(), 4u);
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_r_r.probabilities(), boost::assign::list_of(.25)(.25)(.25)(.25), tol);
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist_r_r.rates(), rates, tol);
+    BOOST_TEST(dist_r_r.num_phases() == 4u);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_r_r.probabilities(), make_vector(.25, .25, .25, .25), tol);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist_r_r.rates(), rates, tol);
 
     // Test copy ctor
     boost::random::hyperexponential_distribution<> cp(dist);
-    BOOST_CHECK_EQUAL(cp, dist);
+    BOOST_TEST(cp == dist);
     boost::random::hyperexponential_distribution<> cp_r(dist_r);
-    BOOST_CHECK_EQUAL(cp_r, dist_r);
+    BOOST_TEST(cp_r == dist_r);
 }
 
 BOOST_AUTO_TEST_CASE( test_param )
 {
     const double tol = detail::make_tolerance<double>();
 
-    const std::vector<double> probs = boost::assign::list_of(0.1)(0.2)(0.3)(0.4);
-    const std::vector<double> rates = boost::assign::list_of(1.0)(2.0)(3.0)(4.0);
+    const std::vector<double> probs{ 0.1, 0.2, 0.3, 0.4 };
+    const std::vector<double> rates{ 1.0, 2.0, 3.0, 4.0 };
 
     // Test param getter
     boost::random::hyperexponential_distribution<> dist(probs, rates);
     boost::random::hyperexponential_distribution<>::param_type param = dist.param();
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist.probabilities(), param.probabilities(), tol);
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist.rates(), param.rates(), tol);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist.probabilities(), param.probabilities(), tol);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist.rates(), param.rates(), tol);
 
     // Test ctor from param
     boost::random::hyperexponential_distribution<> cp1(param);
-    BOOST_CHECK_EQUAL(cp1, dist);
+    BOOST_TEST(cp1 == dist);
 
     // Test param setter
     boost::random::hyperexponential_distribution<> cp2;
     cp2.param(param);
-    BOOST_CHECK_EQUAL(cp2, dist);
+    BOOST_TEST(cp2 == dist);
 
     // Test param constructors & operators
     boost::random::hyperexponential_distribution<>::param_type param_copy = param;
-    BOOST_CHECK_EQUAL(param, param_copy);
+    BOOST_TEST(param == param_copy);
     BOOST_CHECK(param == param_copy);
     BOOST_CHECK(!(param != param_copy));
     boost::random::hyperexponential_distribution<>::param_type param_default;
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, param_default.probabilities(), boost::assign::list_of(1.0), tol);
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, param_default.rates(), boost::assign::list_of(1.0), tol);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(param_default.probabilities(), std::vector<double>{1.0}, tol);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(param_default.rates(), std::vector<double>{1.0}, tol);
     BOOST_CHECK(param != param_default);
     BOOST_CHECK(!(param == param_default));
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) && !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
     boost::random::hyperexponential_distribution<>::param_type param_il = {{1, 2, 3, 4 }, {1, 2, 3, 4}};
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, param_il.probabilities(), boost::assign::list_of(.1)(.2)(.3)(.4), tol);
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, param_il.rates(), boost::assign::list_of(1.)(2.)(3.)(4.), tol);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(param_il.probabilities(), make_vector(.1, .2, .3, .4), tol);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(param_il.rates(), make_vector(1., 2., 3., 4.), tol);
 #endif
     boost::random::hyperexponential_distribution<>::param_type param_r(probs, rates);
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, param_r.probabilities(), probs, tol);
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, param_r.rates(), rates, tol);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(param_r.probabilities(), probs, tol);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(param_r.rates(), rates, tol);
 
     boost::random::hyperexponential_distribution<>::param_type param_it(probs.begin(), probs.end(), rates.begin(), rates.end());
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, param_it.probabilities(), probs, tol);
-    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, param_it.rates(), rates, tol);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(param_it.probabilities(), probs, tol);
+    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(param_it.rates(), rates, tol);
 }
 
 BOOST_AUTO_TEST_CASE( test_min_max )
 {
     //const double tol = detail::make_tolerance<double>();
 
-    const std::vector<double> probs = boost::assign::list_of(0.1)(0.2)(0.3)(0.4);
-    const std::vector<double> rates = boost::assign::list_of(1.0)(2.0)(3.0)(4.0);
+    const std::vector<double> probs{ 0.1, 0.2, 0.3, 0.4 };
+    const std::vector<double> rates{ 1.0, 2.0, 3.0, 4.0 };
 
     boost::random::hyperexponential_distribution<> dist;
-    BOOST_CHECK_EQUAL((dist.min)(), 0);
-    BOOST_CHECK_EQUAL((dist.max)(), (std::numeric_limits<double>::infinity)());
+    BOOST_TEST((dist.min)() == 0);
+    BOOST_TEST((dist.max)() == (std::numeric_limits<double>::infinity)());
 
     boost::random::hyperexponential_distribution<> dist_r(probs, rates);
-    BOOST_CHECK_EQUAL((dist_r.min)(), 0);
-    BOOST_CHECK_EQUAL((dist_r.max)(), (std::numeric_limits<double>::infinity)());
+    BOOST_TEST((dist_r.min)() == 0);
+    BOOST_TEST((dist_r.max)() == (std::numeric_limits<double>::infinity)());
 }
 
 BOOST_AUTO_TEST_CASE(test_comparison)
 {
     //const double tol = detail::make_tolerance<double>();
 
-    const std::vector<double> probs = boost::assign::list_of(0.1)(0.2)(0.3)(0.4);
-    const std::vector<double> rates = boost::assign::list_of(1.0)(2.0)(3.0)(4.0);
+    const std::vector<double> probs{ 0.1, 0.2, 0.3, 0.4 };
+    const std::vector<double> rates{ 1.0, 2.0, 3.0, 4.0 };
 
     boost::random::hyperexponential_distribution<> dist;
     boost::random::hyperexponential_distribution<> dist_copy(dist);
@@ -205,8 +204,8 @@ BOOST_AUTO_TEST_CASE( test_streaming )
 {
     //const double tol = detail::make_tolerance<double>();
 
-    const std::vector<double> probs = boost::assign::list_of(0.1)(0.2)(0.3)(0.4);
-    const std::vector<double> rates = boost::assign::list_of(1.0)(2.0)(3.0)(4.0);
+    const std::vector<double> probs{ 0.1, 0.2, 0.3, 0.4 };
+    const std::vector<double> rates{ 1.0, 2.0, 3.0, 4.0 };
     const std::vector<double> empty_vector;
 
     // Test the reading of param_type
@@ -218,7 +217,7 @@ BOOST_AUTO_TEST_CASE( test_streaming )
         ss << parm;
         boost::random::hyperexponential_distribution<>::param_type restored_parm;
         ss >> restored_parm;
-        BOOST_CHECK_EQUAL(parm, restored_parm);
+        BOOST_TEST(parm == restored_parm);
     }
 
     // - Test with an empty probability vector and ios_base exceptions disabled
@@ -230,7 +229,7 @@ BOOST_AUTO_TEST_CASE( test_streaming )
         boost::random::hyperexponential_distribution<>::param_type param;
         ss >> param;
         boost::random::hyperexponential_distribution<>::param_type check_param(std::vector<double>(rates.size(), 1), rates);
-        BOOST_CHECK_EQUAL(param, check_param);
+        BOOST_TEST(param == check_param);
     }
 
     // - Test with an empty rate vector and ios_base exceptions disabled
@@ -242,7 +241,7 @@ BOOST_AUTO_TEST_CASE( test_streaming )
         boost::random::hyperexponential_distribution<>::param_type param;
         ss >> param;
         boost::random::hyperexponential_distribution<>::param_type check_param(probs, std::vector<double>(probs.size(), 1));
-        BOOST_CHECK_EQUAL(param, check_param);
+        BOOST_TEST(param == check_param);
     }
 
     // - Test with an empty probability and rate vectors and ios_base exceptions disabled
@@ -254,7 +253,7 @@ BOOST_AUTO_TEST_CASE( test_streaming )
         boost::random::hyperexponential_distribution<>::param_type param;
         ss >> param;
         boost::random::hyperexponential_distribution<>::param_type check_param;
-        BOOST_CHECK_EQUAL(param, check_param);
+        BOOST_TEST(param == check_param);
     }
 
     // - Test with an empty probability vector and ios_base exceptions enabled
@@ -267,7 +266,7 @@ BOOST_AUTO_TEST_CASE( test_streaming )
         ss.exceptions(std::ios_base::failbit);
         ss >> param;
         boost::random::hyperexponential_distribution<>::param_type check_param(std::vector<double>(rates.size(), 1), rates);
-        BOOST_CHECK_EQUAL(param, check_param);
+        BOOST_TEST(param == check_param);
     }
 
     // - Test with an empty rate vector and ios_base exceptions enabled
@@ -280,7 +279,7 @@ BOOST_AUTO_TEST_CASE( test_streaming )
         ss.exceptions(std::ios_base::failbit);
         ss >> param;
         boost::random::hyperexponential_distribution<>::param_type check_param(probs, std::vector<double>(probs.size(), 1));
-        BOOST_CHECK_EQUAL(param, check_param);
+        BOOST_TEST(param == check_param);
     }
 
     // - Test with an empty probability and rate vectors and ios_base exceptions enabled
@@ -293,7 +292,7 @@ BOOST_AUTO_TEST_CASE( test_streaming )
         ss.exceptions(std::ios_base::failbit);
         ss >> param;
         boost::random::hyperexponential_distribution<>::param_type check_param;
-        BOOST_CHECK_EQUAL(param, check_param);
+        BOOST_TEST(param == check_param);
     }
 
     // The the reading of hyperexponential_distribution
@@ -305,7 +304,7 @@ BOOST_AUTO_TEST_CASE( test_streaming )
         ss << dist;
         boost::random::hyperexponential_distribution<> restored_dist;
         ss >> restored_dist;
-        BOOST_CHECK_EQUAL(dist, restored_dist);
+        BOOST_TEST(dist == restored_dist);
     }
 
     // - Test with an empty probability vector and ios_base exceptions disabled
@@ -317,7 +316,7 @@ BOOST_AUTO_TEST_CASE( test_streaming )
         boost::random::hyperexponential_distribution<> dist;
         ss >> dist;
         boost::random::hyperexponential_distribution<> check_dist(std::vector<double>(rates.size(), 1), rates);
-        BOOST_CHECK_EQUAL(dist, check_dist);
+        BOOST_TEST(dist == check_dist);
     }
 
     // - Test with an empty rate vector and ios_base exceptions disabled
@@ -329,7 +328,7 @@ BOOST_AUTO_TEST_CASE( test_streaming )
         boost::random::hyperexponential_distribution<> dist;
         ss >> dist;
         boost::random::hyperexponential_distribution<> check_dist(probs, std::vector<double>(probs.size(), 1));
-        BOOST_CHECK_EQUAL(dist, check_dist);
+        BOOST_TEST(dist == check_dist);
     }
 
     // - Test with an empty probability and rate vectors and ios_base exceptions disabled
@@ -341,7 +340,7 @@ BOOST_AUTO_TEST_CASE( test_streaming )
         boost::random::hyperexponential_distribution<> dist;
         ss >> dist;
         boost::random::hyperexponential_distribution<> check_dist;
-        BOOST_CHECK_EQUAL(dist, check_dist);
+        BOOST_TEST(dist == check_dist);
     }
 
     // - Test with an empty probability vector and ios_base exceptions enabled
@@ -354,7 +353,7 @@ BOOST_AUTO_TEST_CASE( test_streaming )
         ss.exceptions(std::ios_base::failbit);
         ss >> dist;
         boost::random::hyperexponential_distribution<> check_dist(std::vector<double>(rates.size(), 1), rates);
-        BOOST_CHECK_EQUAL(dist, check_dist);
+        BOOST_TEST(dist == check_dist);
     }
 
     // - Test with an empty rate vector and ios_base exceptions enabled
@@ -367,7 +366,7 @@ BOOST_AUTO_TEST_CASE( test_streaming )
         ss.exceptions(std::ios_base::failbit);
         ss >> dist;
         boost::random::hyperexponential_distribution<> check_dist(probs, std::vector<double>(probs.size(), 1));
-        BOOST_CHECK_EQUAL(dist, check_dist);
+        BOOST_TEST(dist == check_dist);
     }
 
     // - Test with an empty probability and rate vectors and ios_base exceptions enabled
@@ -380,7 +379,7 @@ BOOST_AUTO_TEST_CASE( test_streaming )
         ss.exceptions(std::ios_base::failbit);
         ss >> dist;
         boost::random::hyperexponential_distribution<> check_dist;
-        BOOST_CHECK_EQUAL(dist, check_dist);
+        BOOST_TEST(dist == check_dist);
     }
 }
 
@@ -389,21 +388,21 @@ BOOST_AUTO_TEST_CASE( test_streaming )
 //{
 //    const double tol = detail::make_tolerance<double>();
 //
-//    const std::vector<double> probs = boost::assign::list_of(1023.0)(1.0);
-//    const std::vector<double> rates = boost::assign::list_of(1023.0)(1.0);
-//    const std::vector<double> norm_probs = boost::assign::list_of(1023.0/1024.0)(1.0/1024.0);
+//    const std::vector<double> probs{ 1023.0, 1.0 };
+//    const std::vector<double> rates{ 1023.0, 1.0 };
+//    const std::vector<double> norm_probs{ 1023.0/1024.0, 1.0/1024.0 };
 //
 //    boost::random::hyperexponential_distribution<> dist(probs, rates);
 //    BOOST_CHECK( boost::random::hyperexp_detail::check_params(dist.probabilities(), dist.rates()) );
-//    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist.probabilities(), norm_probs, tol);
+//    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist.probabilities(), norm_probs, tol);
 //
-//    const std::vector<double> probs2 = boost::assign::list_of(1001.0)(1.0);
-//    const std::vector<double> rates2 = boost::assign::list_of(1001.0)(1.0);
-//    const std::vector<double> norm_probs2 = boost::assign::list_of(1001.0/1002.0)(1.0/1002.0);
+//    const std::vector<double> probs2{ 1001.0, 1.0 };
+//    const std::vector<double> rates2{ 1001.0, 1.0 };
+//    const std::vector<double> norm_probs2{ 1001.0/1002.0, 1.0/1002.0 };
 //
 //    boost::random::hyperexponential_distribution<> dist2(probs2, rates2);
 //    BOOST_CHECK( boost::random::hyperexp_detail::check_params(dist2.probabilities(), dist2.rates()) );
-//    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(double, dist2.probabilities(), norm_probs2, tol);
+//    BOOST_RANDOM_HYPEREXP_CHECK_CLOSE_COLLECTIONS(dist2.probabilities(), norm_probs2, tol);
 //}
 
 void use(boost::random::hyperexponential_distribution<>::result_type) {}
@@ -412,8 +411,8 @@ BOOST_AUTO_TEST_CASE(test_generation)
 {
     //const double tol = detail::make_tolerance<double>();
 
-    const std::vector<double> probs = boost::assign::list_of(0.1)(0.2)(0.3)(0.4);
-    const std::vector<double> rates = boost::assign::list_of(1.0)(2.0)(3.0)(4.0);
+    const std::vector<double> probs{ 0.1, 0.2, 0.3, 0.4 };
+    const std::vector<double> rates{ 1.0, 2.0, 3.0, 4.0 };
 
     boost::minstd_rand0 gen;
 
@@ -424,16 +423,16 @@ BOOST_AUTO_TEST_CASE(test_generation)
     {
         const result_type value = dist(gen);
         use(value);
-        BOOST_CHECK_GE(value, static_cast<result_type>(0));
+        BOOST_TEST(value >= static_cast<result_type>(0));
         const result_type value_r = dist_r(gen);
         use(value_r);
-        BOOST_CHECK_GE(value_r, static_cast<result_type>(0));
+        BOOST_TEST(value_r >= static_cast<result_type>(0));
         const result_type value_param = dist_r(gen, dist.param());
         use(value_param);
-        BOOST_CHECK_GE(value_param, static_cast<result_type>(0));
+        BOOST_TEST(value_param >= static_cast<result_type>(0));
         const result_type value_r_param = dist(gen, dist_r.param());
         use(value_r_param);
-        BOOST_CHECK_GE(value_r_param, static_cast<result_type>(0));
+        BOOST_TEST(value_r_param >= static_cast<result_type>(0));
     }
 }
 
@@ -441,8 +440,8 @@ BOOST_AUTO_TEST_CASE( test_generation_float )
 {
     //const double tol = detail::make_tolerance<double>();
 
-    const std::vector<double> probs = boost::assign::list_of(0.1)(0.2)(0.3)(0.4);
-    const std::vector<double> rates = boost::assign::list_of(1.0)(2.0)(3.0)(4.0);
+    const std::vector<double> probs{ 0.1, 0.2, 0.3, 0.4 };
+    const std::vector<double> rates{ 1.0, 2.0, 3.0, 4.0 };
 
     boost::lagged_fibonacci607 gen;
 
@@ -453,15 +452,15 @@ BOOST_AUTO_TEST_CASE( test_generation_float )
     {
         const result_type value = dist(gen);
         use(value);
-        BOOST_CHECK_GE(value, static_cast<result_type>(0));
+        BOOST_TEST(value >= static_cast<result_type>(0));
         const result_type value_r = dist_r(gen);
         use(value_r);
-        BOOST_CHECK_GE(value_r, static_cast<result_type>(0));
+        BOOST_TEST(value_r >= static_cast<result_type>(0));
         const result_type value_param = dist_r(gen, dist.param());
         use(value_param);
-        BOOST_CHECK_GE(value_param, static_cast<result_type>(0));
+        BOOST_TEST(value_param >= static_cast<result_type>(0));
         const result_type value_r_param = dist(gen, dist_r.param());
         use(value_r_param);
-        BOOST_CHECK_GE(value_r_param, static_cast<result_type>(0));
+        BOOST_TEST(value_r_param >= static_cast<result_type>(0));
     }
 }
diff --git a/test/test_independent_bits31.cpp b/test/test_independent_bits31.cpp
index aaa3f10a4..50a6cb5b4 100644
--- a/test/test_independent_bits31.cpp
+++ b/test/test_independent_bits31.cpp
@@ -12,7 +12,7 @@
 #include <boost/random/independent_bits.hpp>
 #include <boost/random/linear_congruential.hpp>
 
-typedef boost::random::independent_bits_engine<boost::random::minstd_rand0, 31, boost::uint32_t> independent_bits31;
+typedef boost::random::independent_bits_engine<boost::random::minstd_rand0, 31, std::uint32_t> independent_bits31;
 #define BOOST_RANDOM_URNG independent_bits31
 
 #define BOOST_RANDOM_SEED_WORDS 1
diff --git a/test/test_independent_bits32.cpp b/test/test_independent_bits32.cpp
index 6534e8647..f408204e6 100644
--- a/test/test_independent_bits32.cpp
+++ b/test/test_independent_bits32.cpp
@@ -12,7 +12,7 @@
 #include <boost/random/independent_bits.hpp>
 #include <boost/random/mersenne_twister.hpp>
 
-typedef boost::random::independent_bits_engine<boost::random::mt19937, 32, boost::uint32_t> independent_bits32;
+typedef boost::random::independent_bits_engine<boost::random::mt19937, 32, std::uint32_t> independent_bits32;
 #define BOOST_RANDOM_URNG independent_bits32
 
 #define BOOST_RANDOM_SEED_WORDS 624
diff --git a/test/test_knuth_b.cpp b/test/test_knuth_b.cpp
index 7e5b78b03..745f217ed 100644
--- a/test/test_knuth_b.cpp
+++ b/test/test_knuth_b.cpp
@@ -10,7 +10,7 @@
  */
 
 #include <boost/random/shuffle_order.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
 
 #define BOOST_RANDOM_URNG boost::random::knuth_b
 
diff --git a/test/test_kreutzer1986.cpp b/test/test_kreutzer1986.cpp
index 27035252d..6e768a6b0 100644
--- a/test/test_kreutzer1986.cpp
+++ b/test/test_kreutzer1986.cpp
@@ -10,7 +10,7 @@
  */
 
 #include <boost/random/shuffle_order.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
 
 #define BOOST_RANDOM_URNG boost::random::kreutzer1986
 
diff --git a/test/test_lagged_fibonacci.cpp b/test/test_lagged_fibonacci.cpp
index 7f69bcdb9..279376b8f 100644
--- a/test/test_lagged_fibonacci.cpp
+++ b/test/test_lagged_fibonacci.cpp
@@ -11,7 +11,7 @@
 
 #include <boost/random/lagged_fibonacci.hpp>
 
-typedef boost::random::lagged_fibonacci_engine<boost::uint32_t, 24, 607, 273> lagged_fibonacci;
+typedef boost::random::lagged_fibonacci_engine<std::uint32_t, 24, 607, 273> lagged_fibonacci;
 #define BOOST_RANDOM_URNG lagged_fibonacci
 
 #define BOOST_RANDOM_SEED_WORDS 607
diff --git a/test/test_linear_feedback_shift.cpp b/test/test_linear_feedback_shift.cpp
index 7ab70017b..d30138672 100644
--- a/test/test_linear_feedback_shift.cpp
+++ b/test/test_linear_feedback_shift.cpp
@@ -11,7 +11,7 @@
 
 #include <boost/random/linear_feedback_shift.hpp>
 
-typedef boost::random::linear_feedback_shift_engine<boost::uint32_t, 32, 31, 13, 12> linear_feedback_shift;
+typedef boost::random::linear_feedback_shift_engine<std::uint32_t, 32, 31, 13, 12> linear_feedback_shift;
 #define BOOST_RANDOM_URNG linear_feedback_shift
 
 #define BOOST_RANDOM_SEED_WORDS 1
diff --git a/test/test_minstd_rand.cpp b/test/test_minstd_rand.cpp
index 1212c57f2..977d8282f 100644
--- a/test/test_minstd_rand.cpp
+++ b/test/test_minstd_rand.cpp
@@ -10,7 +10,7 @@
  */
 
 #include <boost/random/linear_congruential.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
 
 #define BOOST_RANDOM_URNG boost::random::minstd_rand
 
diff --git a/test/test_minstd_rand0.cpp b/test/test_minstd_rand0.cpp
index ec54e42af..823af1616 100644
--- a/test/test_minstd_rand0.cpp
+++ b/test/test_minstd_rand0.cpp
@@ -10,7 +10,7 @@
  */
 
 #include <boost/random/linear_congruential.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
 
 #define BOOST_RANDOM_URNG boost::random::minstd_rand0
 
diff --git a/test/test_mixmax.cpp b/test/test_mixmax.cpp
index d6d62df51..817ab4f30 100644
--- a/test/test_mixmax.cpp
+++ b/test/test_mixmax.cpp
@@ -29,24 +29,24 @@
 struct seed_seq_0 {
     template<class It>
     void generate(It begin, It end) const {
-        std::fill(begin, end, boost::uint32_t(0xFFFFFFFF));
+        std::fill(begin, end, std::uint32_t(0xFFFFFFFF));
     }
 };
 
 BOOST_AUTO_TEST_CASE(test_special_seed) {
     {
         seed_seq_0 seed;
-        std::vector<boost::uint32_t> vec(17);
+        std::vector<std::uint32_t> vec(17);
         seed.generate(vec.begin(), vec.end()); // fill vec with ones
-        std::vector<boost::uint32_t>::iterator it = vec.begin();
+        std::vector<std::uint32_t>::iterator it = vec.begin();
         boost::random::mixmax gen1(it, vec.end()); // init gen1 with vec iterator
-        BOOST_CHECK_EQUAL(gen1(), 775778250716139533ULL);
-        BOOST_CHECK_EQUAL(gen1(), 846264592759195742ULL);
+        BOOST_TEST(gen1() == 775778250716139533ULL);
+        BOOST_TEST(gen1() == 846264592759195742ULL);
 
         boost::random::mixmax gen2(seed); // init gen2 with seeq_seq, should be the same as gen1!
-        BOOST_CHECK_EQUAL(gen2(), 775778250716139533ULL);
-        BOOST_CHECK_EQUAL(gen2(), 846264592759195742ULL);
+        BOOST_TEST(gen2() == 775778250716139533ULL);
+        BOOST_TEST(gen2() == 846264592759195742ULL);
 
-        BOOST_CHECK_EQUAL(gen1, gen2);
+        BOOST_TEST(gen1 == gen2);
     }
 }
diff --git a/test/test_mt19937.cpp b/test/test_mt19937.cpp
index 568d66891..9e3284df1 100644
--- a/test/test_mt19937.cpp
+++ b/test/test_mt19937.cpp
@@ -12,7 +12,7 @@
 #include <boost/random/mersenne_twister.hpp>
 #include <algorithm>
 #include <vector>
-#include <boost/cstdint.hpp>
+#include <cstdint>
 
 #define BOOST_RANDOM_URNG boost::random::mt19937
 
@@ -33,14 +33,14 @@
 struct seed_seq_0 {
     template<class It>
     void generate(It begin, It end) const {
-        std::fill(begin, end, boost::uint32_t(0));
+        std::fill(begin, end, std::uint32_t(0));
     }
 };
 
 struct seed_seq_1 {
     template<class It>
     void generate(It begin, It end) const {
-        std::fill(begin, end, boost::uint32_t(0));
+        std::fill(begin, end, std::uint32_t(0));
         *(end - 1) = 1;
     }
 };
@@ -48,34 +48,34 @@ struct seed_seq_1 {
 BOOST_AUTO_TEST_CASE(test_special_seed) {
     {
     seed_seq_1 seed;
-    std::vector<boost::uint32_t> vec(624);
+    std::vector<std::uint32_t> vec(624);
     seed.generate(vec.begin(), vec.end());
     
-    std::vector<boost::uint32_t>::iterator it = vec.begin();
+    std::vector<std::uint32_t>::iterator it = vec.begin();
     boost::mt19937 gen1(it, vec.end());
-    BOOST_CHECK_EQUAL(gen1(), 0u);
-    BOOST_CHECK_EQUAL(gen1(), 0u);
+    BOOST_TEST(gen1() == 0u);
+    BOOST_TEST(gen1() == 0u);
     
     boost::mt19937 gen2(seed);
-    BOOST_CHECK_EQUAL(gen2(), 0u);
-    BOOST_CHECK_EQUAL(gen2(), 0u);
+    BOOST_TEST(gen2() == 0u);
+    BOOST_TEST(gen2() == 0u);
 
-    BOOST_CHECK_EQUAL(gen1, gen2);
+    BOOST_TEST(gen1 == gen2);
     }
     {
     seed_seq_0 seed;
-    std::vector<boost::uint32_t> vec(624);
+    std::vector<std::uint32_t> vec(624);
     seed.generate(vec.begin(), vec.end());
     
-    std::vector<boost::uint32_t>::iterator it = vec.begin();
+    std::vector<std::uint32_t>::iterator it = vec.begin();
     boost::mt19937 gen1(it, vec.end());
-    BOOST_CHECK_EQUAL(gen1(), 1141379330u);
-    BOOST_CHECK_EQUAL(gen1(), 0u);
+    BOOST_TEST(gen1() == 1141379330u);
+    BOOST_TEST(gen1() == 0u);
     
     boost::mt19937 gen2(seed);
-    BOOST_CHECK_EQUAL(gen2(), 1141379330u);
-    BOOST_CHECK_EQUAL(gen2(), 0u);
+    BOOST_TEST(gen2() == 1141379330u);
+    BOOST_TEST(gen2() == 0u);
 
-    BOOST_CHECK_EQUAL(gen1, gen2);
+    BOOST_TEST(gen1 == gen2);
     }
 }
diff --git a/test/test_mt19937_64.cpp b/test/test_mt19937_64.cpp
index e3300847b..1875c6099 100644
--- a/test/test_mt19937_64.cpp
+++ b/test/test_mt19937_64.cpp
@@ -10,7 +10,7 @@
  */
 
 #include <boost/random/mersenne_twister.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
 
 #define BOOST_RANDOM_URNG boost::random::mt19937_64
 
diff --git a/test/test_old_uniform_int_distribution.cpp b/test/test_old_uniform_int_distribution.cpp
index bdae26461..5fa912f04 100644
--- a/test/test_old_uniform_int_distribution.cpp
+++ b/test/test_old_uniform_int_distribution.cpp
@@ -10,7 +10,6 @@
  */
 
 #include <boost/random/uniform_int.hpp>
-#include <limits>
 
 #define BOOST_RANDOM_DISTRIBUTION boost::uniform_int<>
 #define BOOST_RANDOM_ARG1 a
@@ -49,13 +48,13 @@
 BOOST_AUTO_TEST_CASE(test_random_shuffle)
 {
 #ifndef BOOST_NO_CXX98_RANDOM_SHUFFLE
-    typedef boost::uniform_int<> distribution_type;
+    typedef boost::uniform_int<std::ptrdiff_t> distribution_type;
     typedef boost::variate_generator<boost::mt19937 &, distribution_type> generator_type;
 
     boost::mt19937 engine1(1234);
     boost::mt19937 engine2(1234);
 
-    boost::random::random_number_generator<boost::mt19937> referenceRand(engine1);
+    boost::random::random_number_generator<boost::mt19937, std::ptrdiff_t> referenceRand(engine1);
 
     distribution_type dist(0,10);
     generator_type testRand(engine2, dist);
@@ -71,8 +70,6 @@ BOOST_AUTO_TEST_CASE(test_random_shuffle)
     std::random_shuffle(referenceVec.begin(), referenceVec.end(), referenceRand);
     std::random_shuffle(testVec.begin(), testVec.end(), testRand);
 
-    BOOST_CHECK_EQUAL_COLLECTIONS(
-        testVec.begin(), testVec.end(),
-        referenceVec.begin(), referenceVec.end());
+    BOOST_TEST(testVec == referenceVec, boost::test_tools::per_element());
 #endif
 }
diff --git a/test/test_old_uniform_real_distribution.cpp b/test/test_old_uniform_real_distribution.cpp
index 1728fb31f..c56027265 100644
--- a/test/test_old_uniform_real_distribution.cpp
+++ b/test/test_old_uniform_real_distribution.cpp
@@ -10,7 +10,6 @@
  */
 
 #include <boost/random/uniform_real.hpp>
-#include <limits>
 
 #define BOOST_RANDOM_DISTRIBUTION boost::uniform_real<>
 #define BOOST_RANDOM_ARG1 a
diff --git a/test/test_piecewise_constant_distribution.cpp b/test/test_piecewise_constant_distribution.cpp
index 793c3e657..f39c1ebef 100644
--- a/test/test_piecewise_constant_distribution.cpp
+++ b/test/test_piecewise_constant_distribution.cpp
@@ -11,7 +11,6 @@
 
 #include <boost/random/piecewise_constant_distribution.hpp>
 #include <boost/random/linear_congruential.hpp>
-#include <boost/assign/list_of.hpp>
 #include <sstream>
 #include <vector>
 #include "concepts.hpp"
@@ -34,108 +33,104 @@ struct gen {
     }
 };
 
-#define CHECK_SEQUENCE(actual, expected)            \
-    do {                                            \
-        std::vector<double> _actual = (actual);     \
-        std::vector<double> _expected = (expected); \
-        BOOST_CHECK_EQUAL_COLLECTIONS(              \
-            _actual.begin(), _actual.end(),         \
-            _expected.begin(), _expected.end());    \
+#define CHECK_SEQUENCE(actual, expected)                                    \
+    do {                                                                    \
+        const std::vector<double>& actual_ = (actual);                      \
+        std::vector<double> expected_ = make_vector<double>expected;        \
+        BOOST_TEST(actual_ == expected_, boost::test_tools::per_element()); \
     } while(false)
 
-using boost::assign::list_of;
-
 BOOST_AUTO_TEST_CASE(test_constructors) {
     boost::random::piecewise_constant_distribution<> dist;
-    CHECK_SEQUENCE(dist.densities(), list_of(1.0));
-    CHECK_SEQUENCE(dist.intervals(), list_of(0.0)(1.0));
+    CHECK_SEQUENCE(dist.densities(), (1.0));
+    CHECK_SEQUENCE(dist.intervals(), (0.0, 1.0));
 
 #ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
     boost::random::piecewise_constant_distribution<> dist_il = {
         { 99, 103, 107, 111, 115 },
         gen()
     };
-    CHECK_SEQUENCE(dist_il.intervals(), list_of(99)(103)(107)(111)(115));
-    CHECK_SEQUENCE(dist_il.densities(), list_of(.03125)(.0625)(.03125)(.125));
+    CHECK_SEQUENCE(dist_il.intervals(), (99, 103, 107, 111, 115));
+    CHECK_SEQUENCE(dist_il.densities(), (.03125, .0625, .03125, .125));
 
     boost::random::piecewise_constant_distribution<> dist_il2 = {
         { 99 },
         gen()
     };
-    CHECK_SEQUENCE(dist_il2.intervals(), list_of(0.0)(1.0));
-    CHECK_SEQUENCE(dist_il2.densities(), list_of(1.0));
+    CHECK_SEQUENCE(dist_il2.intervals(), (0.0, 1.0));
+    CHECK_SEQUENCE(dist_il2.densities(), (1.0));
 #endif
-    std::vector<double> intervals = boost::assign::list_of(0)(1)(2)(3)(5);
-    std::vector<double> weights = boost::assign::list_of(1)(2)(1)(4);
-    std::vector<double> intervals2 = boost::assign::list_of(99);
+    std::vector<double> intervals{ 0, 1, 2, 3, 5 };
+    std::vector<double> weights{ 1, 2, 1, 4 };
+    std::vector<double> intervals2{ 99 };
     std::vector<double> weights2;
 
     boost::random::piecewise_constant_distribution<> dist_r(intervals, weights);
-    CHECK_SEQUENCE(dist_r.intervals(), list_of(0)(1)(2)(3)(5));
-    CHECK_SEQUENCE(dist_r.densities(), list_of(.125)(.25)(.125)(.25));
+    CHECK_SEQUENCE(dist_r.intervals(), (0, 1, 2, 3, 5));
+    CHECK_SEQUENCE(dist_r.densities(), (.125, .25, .125, .25));
 
     boost::random::piecewise_constant_distribution<>
         dist_r2(intervals2, weights2);
-    CHECK_SEQUENCE(dist_r2.intervals(), list_of(0.0)(1.0));
-    CHECK_SEQUENCE(dist_r2.densities(), list_of(1.0));
+    CHECK_SEQUENCE(dist_r2.intervals(), (0.0, 1.0));
+    CHECK_SEQUENCE(dist_r2.densities(), (1.0));
     
     boost::random::piecewise_constant_distribution<> dist_it(
         intervals.begin(), intervals.end(), weights.begin());
-    CHECK_SEQUENCE(dist_it.intervals(), list_of(0)(1)(2)(3)(5));
-    CHECK_SEQUENCE(dist_it.densities(), list_of(.125)(.25)(.125)(.25));
+    CHECK_SEQUENCE(dist_it.intervals(), (0, 1, 2, 3, 5));
+    CHECK_SEQUENCE(dist_it.densities(), (.125, .25, .125, .25));
     
     boost::random::piecewise_constant_distribution<> dist_it2(
         intervals2.begin(), intervals2.end(), weights2.begin());
-    CHECK_SEQUENCE(dist_it2.intervals(), list_of(0.0)(1.0));
-    CHECK_SEQUENCE(dist_it2.densities(), list_of(1.0));
+    CHECK_SEQUENCE(dist_it2.intervals(), (0.0, 1.0));
+    CHECK_SEQUENCE(dist_it2.densities(), (1.0));
     
     boost::random::piecewise_constant_distribution<> dist_fun(4, 99,115, gen());
-    CHECK_SEQUENCE(dist_fun.intervals(), list_of(99)(103)(107)(111)(115));
-    CHECK_SEQUENCE(dist_fun.densities(), list_of(.03125)(.0625)(.03125)(.125));
+    CHECK_SEQUENCE(dist_fun.intervals(), (99, 103, 107, 111, 115));
+    CHECK_SEQUENCE(dist_fun.densities(), (.03125, .0625, .03125, .125));
     
     boost::random::piecewise_constant_distribution<>
         dist_fun2(1, 99, 115, gen());
-    CHECK_SEQUENCE(dist_fun2.intervals(), list_of(99)(115));
-    CHECK_SEQUENCE(dist_fun2.densities(), list_of(0.0625));
+    CHECK_SEQUENCE(dist_fun2.intervals(), (99, 115));
+    CHECK_SEQUENCE(dist_fun2.densities(), (0.0625));
 
     boost::random::piecewise_constant_distribution<> copy(dist);
-    BOOST_CHECK_EQUAL(dist, copy);
+    BOOST_TEST(dist == copy);
     boost::random::piecewise_constant_distribution<> copy_r(dist_r);
-    BOOST_CHECK_EQUAL(dist_r, copy_r);
+    BOOST_TEST(dist_r == copy_r);
 
     boost::random::piecewise_constant_distribution<> notpow2(3, 99, 111, gen());
     BOOST_REQUIRE_EQUAL(notpow2.densities().size(), 3u);
-    BOOST_CHECK_CLOSE_FRACTION(notpow2.densities()[0], 0.0625, 0.00000000001);
-    BOOST_CHECK_CLOSE_FRACTION(notpow2.densities()[1], 0.125, 0.00000000001);
-    BOOST_CHECK_CLOSE_FRACTION(notpow2.densities()[2], 0.0625, 0.00000000001);
+    BOOST_TEST(notpow2.densities()[0] == 0.0625, boost::test_tools::tolerance(0.00000000001));
+    BOOST_TEST(notpow2.densities()[1] == 0.125, boost::test_tools::tolerance(0.00000000001));
+    BOOST_TEST(notpow2.densities()[2] == 0.0625, boost::test_tools::tolerance(0.00000000001));
     boost::random::piecewise_constant_distribution<> copy_notpow2(notpow2);
-    BOOST_CHECK_EQUAL(notpow2, copy_notpow2);
+    BOOST_TEST(notpow2 == copy_notpow2);
 }
 
 BOOST_AUTO_TEST_CASE(test_param) {
-    std::vector<double> intervals = boost::assign::list_of(0)(1)(2)(3)(5);
-    std::vector<double> weights = boost::assign::list_of(1)(2)(1)(4);
-    std::vector<double> intervals2 = boost::assign::list_of(0);
+    std::vector<double> intervals{ 0, 1, 2, 3, 5 };
+    std::vector<double> weights{ 1, 2, 1, 4 };
+    std::vector<double> intervals2{ 0 };
     std::vector<double> weights2;
     boost::random::piecewise_constant_distribution<> dist(intervals, weights);
     boost::random::piecewise_constant_distribution<>::param_type
         param = dist.param();
-    CHECK_SEQUENCE(param.intervals(), list_of(0)(1)(2)(3)(5));
-    CHECK_SEQUENCE(param.densities(), list_of(.125)(.25)(.125)(.25));
+    CHECK_SEQUENCE(param.intervals(), (0, 1, 2, 3, 5));
+    CHECK_SEQUENCE(param.densities(), (.125, .25, .125, .25));
     boost::random::piecewise_constant_distribution<> copy1(param);
-    BOOST_CHECK_EQUAL(dist, copy1);
+    BOOST_TEST(dist == copy1);
     boost::random::piecewise_constant_distribution<> copy2;
     copy2.param(param);
-    BOOST_CHECK_EQUAL(dist, copy2);
+    BOOST_TEST(dist == copy2);
 
     boost::random::piecewise_constant_distribution<>::param_type
         param_copy = param;
-    BOOST_CHECK_EQUAL(param, param_copy);
+    BOOST_TEST(param == param_copy);
     BOOST_CHECK(param == param_copy);
     BOOST_CHECK(!(param != param_copy));
     boost::random::piecewise_constant_distribution<>::param_type param_default;
-    CHECK_SEQUENCE(param_default.intervals(), list_of(0.0)(1.0));
-    CHECK_SEQUENCE(param_default.densities(), list_of(1.0));
+    CHECK_SEQUENCE(param_default.intervals(), (0.0, 1.0));
+    CHECK_SEQUENCE(param_default.densities(), (1.0));
     BOOST_CHECK(param != param_default);
     BOOST_CHECK(!(param == param_default));
     
@@ -144,62 +139,62 @@ BOOST_AUTO_TEST_CASE(test_param) {
         { 99, 103, 107, 111, 115 },
         gen()
     };
-    CHECK_SEQUENCE(parm_il.intervals(), list_of(99)(103)(107)(111)(115));
-    CHECK_SEQUENCE(parm_il.densities(), list_of(.03125)(.0625)(.03125)(.125));
+    CHECK_SEQUENCE(parm_il.intervals(), (99, 103, 107, 111, 115));
+    CHECK_SEQUENCE(parm_il.densities(), (.03125, .0625, .03125, .125));
 
     boost::random::piecewise_constant_distribution<>::param_type parm_il2 = {
         { 99 },
         gen()
     };
-    CHECK_SEQUENCE(parm_il2.intervals(), list_of(0.0)(1.0));
-    CHECK_SEQUENCE(parm_il2.densities(), list_of(1.0));
+    CHECK_SEQUENCE(parm_il2.intervals(), (0.0, 1.0));
+    CHECK_SEQUENCE(parm_il2.densities(), (1.0));
 #endif
 
     boost::random::piecewise_constant_distribution<>::param_type
         parm_r(intervals, weights);
-    CHECK_SEQUENCE(parm_r.intervals(), list_of(0)(1)(2)(3)(5));
-    CHECK_SEQUENCE(parm_r.densities(), list_of(.125)(.25)(.125)(.25));
+    CHECK_SEQUENCE(parm_r.intervals(), (0, 1, 2, 3, 5));
+    CHECK_SEQUENCE(parm_r.densities(), (.125, .25, .125, .25));
 
     boost::random::piecewise_constant_distribution<>::param_type
         parm_r2(intervals2, weights2);
-    CHECK_SEQUENCE(parm_r2.intervals(), list_of(0.0)(1.0));
-    CHECK_SEQUENCE(parm_r2.densities(), list_of(1.0));
+    CHECK_SEQUENCE(parm_r2.intervals(), (0.0, 1.0));
+    CHECK_SEQUENCE(parm_r2.densities(), (1.0));
     
     boost::random::piecewise_constant_distribution<>::param_type
         parm_it(intervals.begin(), intervals.end(), weights.begin());
-    CHECK_SEQUENCE(parm_it.intervals(), list_of(0)(1)(2)(3)(5));
-    CHECK_SEQUENCE(parm_it.densities(), list_of(.125)(.25)(.125)(.25));
+    CHECK_SEQUENCE(parm_it.intervals(), (0, 1, 2, 3, 5));
+    CHECK_SEQUENCE(parm_it.densities(), (.125, .25, .125, .25));
     
     boost::random::piecewise_constant_distribution<>::param_type
         parm_it2(intervals2.begin(), intervals2.end(), weights2.begin());
-    CHECK_SEQUENCE(parm_it2.intervals(), list_of(0.0)(1.0));
-    CHECK_SEQUENCE(parm_it2.densities(), list_of(1.0));
+    CHECK_SEQUENCE(parm_it2.intervals(), (0.0, 1.0));
+    CHECK_SEQUENCE(parm_it2.densities(), (1.0));
     
     boost::random::piecewise_constant_distribution<>::param_type
         parm_fun(4, 99, 115, gen());
-    CHECK_SEQUENCE(parm_fun.intervals(), list_of(99)(103)(107)(111)(115));
-    CHECK_SEQUENCE(parm_fun.densities(), list_of(.03125)(.0625)(.03125)(.125));
+    CHECK_SEQUENCE(parm_fun.intervals(), (99, 103, 107, 111, 115));
+    CHECK_SEQUENCE(parm_fun.densities(), (.03125, .0625, .03125, .125));
     
     boost::random::piecewise_constant_distribution<>::param_type
         parm_fun2(1, 99, 115, gen());
-    CHECK_SEQUENCE(parm_fun2.intervals(), list_of(99)(115));
-    CHECK_SEQUENCE(parm_fun2.densities(), list_of(0.0625));
+    CHECK_SEQUENCE(parm_fun2.intervals(), (99, 115));
+    CHECK_SEQUENCE(parm_fun2.densities(), (0.0625));
 }
 
 BOOST_AUTO_TEST_CASE(test_min_max) {
-    std::vector<double> intervals = boost::assign::list_of(0)(1)(2)(3)(5);
-    std::vector<double> weights = boost::assign::list_of(1)(2)(1)(4);
+    std::vector<double> intervals{ 0, 1, 2, 3, 5 };
+    std::vector<double> weights{ 1, 2, 1, 4 };
     boost::random::piecewise_constant_distribution<> dist;
-    BOOST_CHECK_EQUAL((dist.min)(), 0.0);
-    BOOST_CHECK_EQUAL((dist.max)(), 1.0);
+    BOOST_TEST((dist.min)() == 0.0);
+    BOOST_TEST((dist.max)() == 1.0);
     boost::random::piecewise_constant_distribution<> dist_r(intervals, weights);
-    BOOST_CHECK_EQUAL((dist_r.min)(), 0.0);
-    BOOST_CHECK_EQUAL((dist_r.max)(), 5.0);
+    BOOST_TEST((dist_r.min)() == 0.0);
+    BOOST_TEST((dist_r.max)() == 5.0);
 }
 
 BOOST_AUTO_TEST_CASE(test_comparison) {
-    std::vector<double> intervals = boost::assign::list_of(0)(1)(2)(3)(5);
-    std::vector<double> weights = boost::assign::list_of(1)(2)(1)(4);
+    std::vector<double> intervals{ 0, 1, 2, 3, 5 };
+    std::vector<double> weights{ 1, 2, 1, 4 };
     boost::random::piecewise_constant_distribution<> dist;
     boost::random::piecewise_constant_distribution<> dist_copy(dist);
     boost::random::piecewise_constant_distribution<> dist_r(intervals, weights);
@@ -213,34 +208,34 @@ BOOST_AUTO_TEST_CASE(test_comparison) {
 }
 
 BOOST_AUTO_TEST_CASE(test_streaming) {
-    std::vector<double> intervals = boost::assign::list_of(0)(1)(2)(3)(5);
-    std::vector<double> weights = boost::assign::list_of(1)(2)(1)(4);
+    std::vector<double> intervals{ 0, 1, 2, 3, 5 };
+    std::vector<double> weights{ 1, 2, 1, 4 };
     boost::random::piecewise_constant_distribution<> dist(intervals, weights);
     std::stringstream stream;
     stream << dist;
     boost::random::piecewise_constant_distribution<> restored_dist;
     stream >> restored_dist;
-    BOOST_CHECK_EQUAL(dist, restored_dist);
+    BOOST_TEST(dist == restored_dist);
 }
 
 BOOST_AUTO_TEST_CASE(test_generation) {
-    std::vector<double> intervals = boost::assign::list_of(1)(2);
-    std::vector<double> weights = boost::assign::list_of(1);
+    std::vector<double> intervals{ 1, 2 };
+    std::vector<double> weights{ 1 };
     boost::minstd_rand0 gen;
     boost::random::piecewise_constant_distribution<> dist;
     boost::random::piecewise_constant_distribution<> dist_r(intervals, weights);
     for(int i = 0; i < 10; ++i) {
         double value = dist(gen);
-        BOOST_CHECK_GE(value, 0.0);
-        BOOST_CHECK_LT(value, 1.0);
+        BOOST_TEST(value >= 0.0);
+        BOOST_TEST(value < 1.0);
         double value_r = dist_r(gen);
-        BOOST_CHECK_GE(value_r, 1.0);
-        BOOST_CHECK_LT(value_r, 2.0);
+        BOOST_TEST(value_r >= 1.0);
+        BOOST_TEST(value_r < 2.0);
         double value_param = dist_r(gen, dist.param());
-        BOOST_CHECK_GE(value_param, 0.0);
-        BOOST_CHECK_LT(value_param, 1.0);
+        BOOST_TEST(value_param >= 0.0);
+        BOOST_TEST(value_param < 1.0);
         double value_r_param = dist(gen, dist_r.param());
-        BOOST_CHECK_GE(value_r_param, 1.0);
-        BOOST_CHECK_LT(value_r_param, 2.0);
+        BOOST_TEST(value_r_param >= 1.0);
+        BOOST_TEST(value_r_param < 2.0);
     }
 }
diff --git a/test/test_piecewise_linear_distribution.cpp b/test/test_piecewise_linear_distribution.cpp
index 9426de283..924e1eeaa 100644
--- a/test/test_piecewise_linear_distribution.cpp
+++ b/test/test_piecewise_linear_distribution.cpp
@@ -11,7 +11,6 @@
 
 #include <boost/random/piecewise_linear_distribution.hpp>
 #include <boost/random/linear_congruential.hpp>
-#include <boost/assign/list_of.hpp>
 #include <sstream>
 #include <vector>
 #include "concepts.hpp"
@@ -35,111 +34,107 @@ struct gen {
     }
 };
 
-#define CHECK_SEQUENCE(actual, expected)            \
-    do {                                            \
-        std::vector<double> _actual = (actual);     \
-        std::vector<double> _expected = (expected); \
-        BOOST_CHECK_EQUAL_COLLECTIONS(              \
-            _actual.begin(), _actual.end(),         \
-            _expected.begin(), _expected.end());    \
+#define CHECK_SEQUENCE(actual, expected)                                    \
+    do {                                                                    \
+        const std::vector<double>& actual_ = (actual);                      \
+        std::vector<double> expected_ = make_vector<double>expected;        \
+        BOOST_TEST(actual_ == expected_, boost::test_tools::per_element()); \
     } while(false)
 
-using boost::assign::list_of;
-
 BOOST_AUTO_TEST_CASE(test_constructors) {
     boost::random::piecewise_linear_distribution<> dist;
-    CHECK_SEQUENCE(dist.intervals(), list_of(0.0)(1.0));
-    CHECK_SEQUENCE(dist.densities(), list_of(1.0)(1.0));
+    CHECK_SEQUENCE(dist.intervals(), (0.0, 1.0));
+    CHECK_SEQUENCE(dist.densities(), (1.0, 1.0));
 
 #ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
     boost::random::piecewise_linear_distribution<> dist_il = {
         { 99, 103, 107, 111, 115 },
         gen()
     };
-    CHECK_SEQUENCE(dist_il.intervals(), list_of(99)(103)(107)(111)(115));
+    CHECK_SEQUENCE(dist_il.intervals(), (99, 103, 107, 111, 115));
     CHECK_SEQUENCE(dist_il.densities(),
-        list_of(.09375)(.03125)(0.0625)(.03125)(.15625));
+        (.09375, .03125, 0.0625, .03125, .15625));
 
     boost::random::piecewise_linear_distribution<> dist_il2 = {
         { 99 },
         gen()
     };
-    CHECK_SEQUENCE(dist_il2.intervals(), list_of(0.0)(1.0));
-    CHECK_SEQUENCE(dist_il2.densities(), list_of(1.0)(1.0));
+    CHECK_SEQUENCE(dist_il2.intervals(), (0.0, 1.0));
+    CHECK_SEQUENCE(dist_il2.densities(), (1.0, 1.0));
 #endif
-    std::vector<double> intervals = boost::assign::list_of(0)(1)(2)(3)(5);
-    std::vector<double> weights = boost::assign::list_of(3)(1)(2)(1)(2);
-    std::vector<double> intervals2 = boost::assign::list_of(99);
-    std::vector<double> weights2 = boost::assign::list_of(2);
+    std::vector<double> intervals{ 0, 1, 2, 3, 5 };
+    std::vector<double> weights{ 3, 1, 2, 1, 2 };
+    std::vector<double> intervals2{ 99 };
+    std::vector<double> weights2{ 2 };
 
     boost::random::piecewise_linear_distribution<> dist_r(intervals, weights);
-    CHECK_SEQUENCE(dist_r.intervals(), list_of(0)(1)(2)(3)(5));
-    CHECK_SEQUENCE(dist_r.densities(), list_of(.375)(.125)(.25)(.125)(.25));
+    CHECK_SEQUENCE(dist_r.intervals(), (0, 1, 2, 3, 5));
+    CHECK_SEQUENCE(dist_r.densities(), (.375, .125, .25, .125, .25));
 
     boost::random::piecewise_linear_distribution<>
         dist_r2(intervals2, weights2);
-    CHECK_SEQUENCE(dist_r2.intervals(), list_of(0.0)(1.0));
-    CHECK_SEQUENCE(dist_r2.densities(), list_of(1.0)(1.0));
+    CHECK_SEQUENCE(dist_r2.intervals(), (0.0, 1.0));
+    CHECK_SEQUENCE(dist_r2.densities(), (1.0, 1.0));
     
     boost::random::piecewise_linear_distribution<> dist_it(
         intervals.begin(), intervals.end(), weights.begin());
-    CHECK_SEQUENCE(dist_it.intervals(), list_of(0)(1)(2)(3)(5));
-    CHECK_SEQUENCE(dist_it.densities(), list_of(.375)(.125)(.25)(.125)(.25));
+    CHECK_SEQUENCE(dist_it.intervals(), (0, 1, 2, 3, 5));
+    CHECK_SEQUENCE(dist_it.densities(), (.375, .125, .25, .125, .25));
     
     boost::random::piecewise_linear_distribution<> dist_it2(
         intervals2.begin(), intervals2.end(), weights2.begin());
-    CHECK_SEQUENCE(dist_it2.intervals(), list_of(0.0)(1.0));
-    CHECK_SEQUENCE(dist_it2.densities(), list_of(1.0)(1.0));
+    CHECK_SEQUENCE(dist_it2.intervals(), (0.0, 1.0));
+    CHECK_SEQUENCE(dist_it2.densities(), (1.0, 1.0));
     
-    boost::random::piecewise_linear_distribution<> dist_fun(4, 99,115, gen());
-    CHECK_SEQUENCE(dist_fun.intervals(), list_of(99)(103)(107)(111)(115));
+    boost::random::piecewise_linear_distribution<> dist_fun(4, 99, 115, gen());
+    CHECK_SEQUENCE(dist_fun.intervals(), (99, 103, 107, 111, 115));
     CHECK_SEQUENCE(dist_fun.densities(),
-        list_of(.09375)(.03125)(0.0625)(.03125)(.15625));
+        (.09375, .03125, 0.0625, .03125, .15625));
     
     boost::random::piecewise_linear_distribution<>
         dist_fun2(1, 99, 115, gen());
-    CHECK_SEQUENCE(dist_fun2.intervals(), list_of(99)(115));
-    CHECK_SEQUENCE(dist_fun2.densities(), list_of(0.046875)(0.078125));
+    CHECK_SEQUENCE(dist_fun2.intervals(), (99, 115));
+    CHECK_SEQUENCE(dist_fun2.densities(), (0.046875, 0.078125));
 
     boost::random::piecewise_linear_distribution<> copy(dist);
-    BOOST_CHECK_EQUAL(dist, copy);
+    BOOST_TEST(dist == copy);
     boost::random::piecewise_linear_distribution<> copy_r(dist_r);
-    BOOST_CHECK_EQUAL(dist_r, copy_r);
+    BOOST_TEST(dist_r == copy_r);
 
     boost::random::piecewise_linear_distribution<> notpow2(3, 99, 111, gen());
     BOOST_REQUIRE_EQUAL(notpow2.densities().size(), 4u);
-    BOOST_CHECK_CLOSE_FRACTION(notpow2.densities()[0], 0.15, 1e-12);
-    BOOST_CHECK_CLOSE_FRACTION(notpow2.densities()[1], 0.05, 1e-12);
-    BOOST_CHECK_CLOSE_FRACTION(notpow2.densities()[2], 0.1, 1e-12);
-    BOOST_CHECK_CLOSE_FRACTION(notpow2.densities()[3], 0.05, 1e-12);
+    BOOST_TEST(notpow2.densities()[0] == 0.15, boost::test_tools::tolerance(1e-12));
+    BOOST_TEST(notpow2.densities()[1] == 0.05, boost::test_tools::tolerance(1e-12));
+    BOOST_TEST(notpow2.densities()[2] == 0.1, boost::test_tools::tolerance(1e-12));
+    BOOST_TEST(notpow2.densities()[3] == 0.05, boost::test_tools::tolerance(1e-12));
     boost::random::piecewise_linear_distribution<> copy_notpow2(notpow2);
-    BOOST_CHECK_EQUAL(notpow2, copy_notpow2);
+    BOOST_TEST(notpow2 == copy_notpow2);
 }
 
 BOOST_AUTO_TEST_CASE(test_param) {
-    std::vector<double> intervals = boost::assign::list_of(0)(1)(2)(3)(5);
-    std::vector<double> weights = boost::assign::list_of(3)(1)(2)(1)(2);
-    std::vector<double> intervals2 = boost::assign::list_of(99);
-    std::vector<double> weights2 = boost::assign::list_of(2);
+    std::vector<double> intervals{ 0, 1, 2, 3, 5 };
+    std::vector<double> weights{ 3, 1, 2, 1, 2 };
+    std::vector<double> intervals2{ 99 };
+    std::vector<double> weights2{ 2 };
     boost::random::piecewise_linear_distribution<> dist(intervals, weights);
     boost::random::piecewise_linear_distribution<>::param_type
         param = dist.param();
-    CHECK_SEQUENCE(param.intervals(), list_of(0)(1)(2)(3)(5));
-    CHECK_SEQUENCE(param.densities(), list_of(.375)(.125)(.25)(.125)(.25));
+    CHECK_SEQUENCE(param.intervals(), (0, 1, 2, 3, 5));
+    CHECK_SEQUENCE(param.densities(), (.375, .125, .25, .125, .25));
     boost::random::piecewise_linear_distribution<> copy1(param);
-    BOOST_CHECK_EQUAL(dist, copy1);
+    BOOST_TEST(dist == copy1);
     boost::random::piecewise_linear_distribution<> copy2;
     copy2.param(param);
-    BOOST_CHECK_EQUAL(dist, copy2);
+    BOOST_TEST(dist == copy2);
 
     boost::random::piecewise_linear_distribution<>::param_type
         param_copy = param;
-    BOOST_CHECK_EQUAL(param, param_copy);
+    BOOST_TEST(param == param_copy);
     BOOST_CHECK(param == param_copy);
     BOOST_CHECK(!(param != param_copy));
     boost::random::piecewise_linear_distribution<>::param_type param_default;
-    CHECK_SEQUENCE(param_default.intervals(), list_of(0.0)(1.0));
-    CHECK_SEQUENCE(param_default.densities(), list_of(1.0)(1.0));
+    CHECK_SEQUENCE(param_default.intervals(), (0.0, 1.0));
+    CHECK_SEQUENCE(param_default.densities(), (1.0, 1.0));
     BOOST_CHECK(param != param_default);
     BOOST_CHECK(!(param == param_default));
     
@@ -148,64 +143,64 @@ BOOST_AUTO_TEST_CASE(test_param) {
         { 99, 103, 107, 111, 115 },
         gen()
     };
-    CHECK_SEQUENCE(parm_il.intervals(), list_of(99)(103)(107)(111)(115));
+    CHECK_SEQUENCE(parm_il.intervals(), (99, 103, 107, 111, 115));
     CHECK_SEQUENCE(parm_il.densities(),
-        list_of(.09375)(.03125)(0.0625)(.03125)(.15625));
+        (.09375, .03125, 0.0625, .03125, .15625));
 
     boost::random::piecewise_linear_distribution<>::param_type parm_il2 = {
         { 99 },
         gen()
     };
-    CHECK_SEQUENCE(parm_il2.intervals(), list_of(0.0)(1.0));
-    CHECK_SEQUENCE(parm_il2.densities(), list_of(1.0)(1.0));
+    CHECK_SEQUENCE(parm_il2.intervals(), (0.0, 1.0));
+    CHECK_SEQUENCE(parm_il2.densities(), (1.0, 1.0));
 #endif
 
     boost::random::piecewise_linear_distribution<>::param_type
         parm_r(intervals, weights);
-    CHECK_SEQUENCE(parm_r.intervals(), list_of(0)(1)(2)(3)(5));
-    CHECK_SEQUENCE(parm_r.densities(), list_of(.375)(.125)(.25)(.125)(.25));
+    CHECK_SEQUENCE(parm_r.intervals(), (0, 1, 2, 3, 5));
+    CHECK_SEQUENCE(parm_r.densities(), (.375, .125, .25, .125, .25));
 
     boost::random::piecewise_linear_distribution<>::param_type
         parm_r2(intervals2, weights2);
-    CHECK_SEQUENCE(parm_r2.intervals(), list_of(0.0)(1.0));
-    CHECK_SEQUENCE(parm_r2.densities(), list_of(1.0)(1.0));
+    CHECK_SEQUENCE(parm_r2.intervals(), (0.0, 1.0));
+    CHECK_SEQUENCE(parm_r2.densities(), (1.0, 1.0));
     
     boost::random::piecewise_linear_distribution<>::param_type
         parm_it(intervals.begin(), intervals.end(), weights.begin());
-    CHECK_SEQUENCE(parm_it.intervals(), list_of(0)(1)(2)(3)(5));
-    CHECK_SEQUENCE(parm_it.densities(), list_of(.375)(.125)(.25)(.125)(.25));
+    CHECK_SEQUENCE(parm_it.intervals(), (0, 1, 2, 3, 5));
+    CHECK_SEQUENCE(parm_it.densities(), (.375, .125, .25, .125, .25));
     
     boost::random::piecewise_linear_distribution<>::param_type
         parm_it2(intervals2.begin(), intervals2.end(), weights2.begin());
-    CHECK_SEQUENCE(parm_it2.intervals(), list_of(0.0)(1.0));
-    CHECK_SEQUENCE(parm_it2.densities(), list_of(1.0)(1.0));
+    CHECK_SEQUENCE(parm_it2.intervals(), (0.0, 1.0));
+    CHECK_SEQUENCE(parm_it2.densities(), (1.0, 1.0));
     
     boost::random::piecewise_linear_distribution<>::param_type
         parm_fun(4, 99, 115, gen());
-    CHECK_SEQUENCE(parm_fun.intervals(), list_of(99)(103)(107)(111)(115));
+    CHECK_SEQUENCE(parm_fun.intervals(), (99, 103, 107, 111, 115));
     CHECK_SEQUENCE(parm_fun.densities(),
-        list_of(.09375)(.03125)(0.0625)(.03125)(.15625));
+        (.09375, .03125, 0.0625, .03125, .15625));
     
     boost::random::piecewise_linear_distribution<>::param_type
         parm_fun2(1, 99, 115, gen());
-    CHECK_SEQUENCE(parm_fun2.intervals(), list_of(99)(115));
-    CHECK_SEQUENCE(parm_fun2.densities(), list_of(0.046875)(0.078125));
+    CHECK_SEQUENCE(parm_fun2.intervals(), (99, 115));
+    CHECK_SEQUENCE(parm_fun2.densities(), (0.046875, 0.078125));
 }
 
 BOOST_AUTO_TEST_CASE(test_min_max) {
-    std::vector<double> intervals = boost::assign::list_of(0)(1)(2)(3)(5);
-    std::vector<double> weights = boost::assign::list_of(3)(1)(2)(1)(2);
+    std::vector<double> intervals{ 0, 1, 2, 3, 5 };
+    std::vector<double> weights{ 3, 1, 2, 1, 2 };
     boost::random::piecewise_linear_distribution<> dist;
-    BOOST_CHECK_EQUAL((dist.min)(), 0.0);
-    BOOST_CHECK_EQUAL((dist.max)(), 1.0);
+    BOOST_TEST((dist.min)() == 0.0);
+    BOOST_TEST((dist.max)() == 1.0);
     boost::random::piecewise_linear_distribution<> dist_r(intervals, weights);
-    BOOST_CHECK_EQUAL((dist_r.min)(), 0.0);
-    BOOST_CHECK_EQUAL((dist_r.max)(), 5.0);
+    BOOST_TEST((dist_r.min)() == 0.0);
+    BOOST_TEST((dist_r.max)() == 5.0);
 }
 
 BOOST_AUTO_TEST_CASE(test_comparison) {
-    std::vector<double> intervals = boost::assign::list_of(0)(1)(2)(3)(5);
-    std::vector<double> weights = boost::assign::list_of(3)(1)(2)(1)(2);
+    std::vector<double> intervals{ 0, 1, 2, 3, 5 };
+    std::vector<double> weights{ 3, 1, 2, 1, 2 };
     boost::random::piecewise_linear_distribution<> dist;
     boost::random::piecewise_linear_distribution<> dist_copy(dist);
     boost::random::piecewise_linear_distribution<> dist_r(intervals, weights);
@@ -219,34 +214,34 @@ BOOST_AUTO_TEST_CASE(test_comparison) {
 }
 
 BOOST_AUTO_TEST_CASE(test_streaming) {
-    std::vector<double> intervals = boost::assign::list_of(0)(1)(2)(3)(5);
-    std::vector<double> weights = boost::assign::list_of(3)(1)(2)(1)(2);
+    std::vector<double> intervals{ 0, 1, 2, 3, 5 };
+    std::vector<double> weights{ 3, 1, 2, 1, 2 };
     boost::random::piecewise_linear_distribution<> dist(intervals, weights);
     std::stringstream stream;
     stream << dist;
     boost::random::piecewise_linear_distribution<> restored_dist;
     stream >> restored_dist;
-    BOOST_CHECK_EQUAL(dist, restored_dist);
+    BOOST_TEST(dist == restored_dist);
 }
 
 BOOST_AUTO_TEST_CASE(test_generation) {
-    std::vector<double> intervals = boost::assign::list_of(1)(2);
-    std::vector<double> weights = boost::assign::list_of(1)(1);
+    std::vector<double> intervals{ 1, 2 };
+    std::vector<double> weights{ 1, 1 };
     boost::minstd_rand0 gen;
     boost::random::piecewise_linear_distribution<> dist;
     boost::random::piecewise_linear_distribution<> dist_r(intervals, weights);
     for(int i = 0; i < 10; ++i) {
         double value = dist(gen);
-        BOOST_CHECK_GE(value, 0.0);
-        BOOST_CHECK_LT(value, 1.0);
+        BOOST_TEST(value >= 0.0);
+        BOOST_TEST(value < 1.0);
         double value_r = dist_r(gen);
-        BOOST_CHECK_GE(value_r, 1.0);
-        BOOST_CHECK_LT(value_r, 2.0);
+        BOOST_TEST(value_r >= 1.0);
+        BOOST_TEST(value_r < 2.0);
         double value_param = dist_r(gen, dist.param());
-        BOOST_CHECK_GE(value_param, 0.0);
-        BOOST_CHECK_LT(value_param, 1.0);
+        BOOST_TEST(value_param >= 0.0);
+        BOOST_TEST(value_param < 1.0);
         double value_r_param = dist(gen, dist_r.param());
-        BOOST_CHECK_GE(value_r_param, 1.0);
-        BOOST_CHECK_LT(value_r_param, 2.0);
+        BOOST_TEST(value_r_param >= 1.0);
+        BOOST_TEST(value_r_param < 2.0);
     }
 }
diff --git a/test/test_qrng_functions.hpp b/test/test_qrng_functions.hpp
index effc96007..e39fe1436 100644
--- a/test/test_qrng_functions.hpp
+++ b/test/test_qrng_functions.hpp
@@ -6,8 +6,9 @@
 #ifndef TEST_QRNG_FUNCTIONS_HPP_INCLUDED
 #define TEST_QRNG_FUNCTIONS_HPP_INCLUDED
 
+#include <cstdint>
 #include <boost/random/uniform_real.hpp>
-#include <boost/test/floating_point_comparison.hpp>
+#include <boost/test/tools/floating_point_comparison.hpp>
 
 #include <sstream>
 
@@ -16,7 +17,7 @@ namespace test {
 // Invokes operator() precisely n times. This is to check that
 // Engine::discard(n) actually has the same effect.
 template<typename Engine>
-inline void trivial_discard(Engine& eng, boost::uintmax_t n)
+inline void trivial_discard(Engine& eng, std::uintmax_t n)
 {
   for( ; n != 0; --n ) eng();
 }
@@ -166,7 +167,7 @@ void test_max_discard(std::size_t dim)
 {
   typedef typename Generator::type engine_type;
 
-  static const boost::uintmax_t maxdiscard = dim * engine_type::max();
+  static const std::uintmax_t maxdiscard = dim * engine_type::max();
 
   // Max discard limit
   {
@@ -265,13 +266,13 @@ inline void test_##QRNG##_max_discard() \
   static const std::size_t dim = 2;\
    \
    /* test full 8 bits */ \
-  test::test_max_discard<gen_engine<boost::uint8_t, 8u> >(dim); \
+  test::test_max_discard<gen_engine<std::uint8_t, 8u> >(dim); \
   \
   /* test 7 bits */ \
-  test::test_max_discard<gen_engine<boost::uint8_t, 7u> >(dim); \
+  test::test_max_discard<gen_engine<std::uint8_t, 7u> >(dim); \
   \
   /* test 6 bits for a good measure */ \
-  test::test_max_discard<gen_engine<boost::uint8_t, 6u> >(dim); \
+  test::test_max_discard<gen_engine<std::uint8_t, 6u> >(dim); \
 } \
 /**/
 
diff --git a/test/test_rand48.cpp b/test/test_rand48.cpp
index 79b61c13b..62761a0d3 100644
--- a/test/test_rand48.cpp
+++ b/test/test_rand48.cpp
@@ -10,7 +10,7 @@
  */
 
 #include <boost/random/linear_congruential.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
 
 #define BOOST_RANDOM_URNG boost::random::rand48
 
diff --git a/test/test_random_device.cpp b/test/test_random_device.cpp
index 1ae01dd06..5e7e05e06 100644
--- a/test/test_random_device.cpp
+++ b/test/test_random_device.cpp
@@ -1,6 +1,7 @@
 /* boost random_test.cpp various tests
  *
  * Copyright (c) 2010 Steven Watanabe
+ * Copyright (c) 2016 Alexander Grund
  * Distributed under the Boost Software License, Version 1.0. (See
  * accompanying file LICENSE_1_0.txt or copy at
  * http://www.boost.org/LICENCE_1_0.txt)
@@ -10,25 +11,28 @@
 
 #include <boost/random/random_device.hpp>
 
-#include <boost/test/test_tools.hpp>
-#include <boost/test/included/test_exec_monitor.hpp>
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
 
 #ifndef BOOST_NO_CXX11_CONSTEXPR
 constexpr boost::random_device::result_type const_min = (boost::random_device::min)();
 constexpr boost::random_device::result_type const_max = (boost::random_device::max)();
 #endif
 
-int test_main(int, char**) {
+BOOST_AUTO_TEST_CASE(test_random_device)
+{
+    boost::ignore_unused(const_min);
+    boost::ignore_unused(const_max);
+
     boost::random_device rng;
     double entropy = rng.entropy();
-    BOOST_CHECK_GE(entropy, 0);
+    BOOST_TEST(entropy >= 0);
     for(int i = 0; i < 100; ++i) {
         boost::random_device::result_type val = rng();
-        BOOST_CHECK_GE(val, (rng.min)());
-        BOOST_CHECK_LE(val, (rng.max)());
+        BOOST_TEST(val >= (rng.min)());
+        BOOST_TEST(val <= (rng.max)());
     }
 
-    boost::uint32_t a[10];
+    std::uint32_t a[10];
     rng.generate(a, a + 10);
-    return 0;
 }
diff --git a/test/test_random_number_generator.cpp b/test/test_random_number_generator.cpp
index 14add59cf..dd43a48f4 100644
--- a/test/test_random_number_generator.cpp
+++ b/test/test_random_number_generator.cpp
@@ -22,7 +22,7 @@ BOOST_AUTO_TEST_CASE(test_random_shuffle)
 {
 #ifndef BOOST_NO_CXX98_RANDOM_SHUFFLE
     boost::mt19937 engine(1234);
-    boost::random::random_number_generator<boost::mt19937> generator(engine);
+    boost::random::random_number_generator<boost::mt19937, std::ptrdiff_t> generator(engine);
 
     std::vector<int> testVec;
 
diff --git a/test/test_ranlux48.cpp b/test/test_ranlux48.cpp
index bd4fa092b..18c5af323 100644
--- a/test/test_ranlux48.cpp
+++ b/test/test_ranlux48.cpp
@@ -10,7 +10,7 @@
  */
 
 #include <boost/random/ranlux.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
 
 #define BOOST_RANDOM_URNG boost::random::ranlux48
 
diff --git a/test/test_ranlux48_base.cpp b/test/test_ranlux48_base.cpp
index 3f5571312..ca9755954 100644
--- a/test/test_ranlux48_base.cpp
+++ b/test/test_ranlux48_base.cpp
@@ -10,7 +10,7 @@
  */
 
 #include <boost/random/ranlux.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
 
 #define BOOST_RANDOM_URNG boost::random::ranlux48_base
 
diff --git a/test/test_ranlux64_3.cpp b/test/test_ranlux64_3.cpp
index 0c9fbdec6..0a632a48e 100644
--- a/test/test_ranlux64_3.cpp
+++ b/test/test_ranlux64_3.cpp
@@ -10,8 +10,8 @@
  */
 
 #include <boost/random/ranlux.hpp>
-#include <boost/cstdint.hpp>
 #include <cmath>
+#include <cstdint>
 
 #define BOOST_RANDOM_URNG boost::random::ranlux64_3
 
diff --git a/test/test_ranlux64_4.cpp b/test/test_ranlux64_4.cpp
index df1c5427a..b06170a3a 100644
--- a/test/test_ranlux64_4.cpp
+++ b/test/test_ranlux64_4.cpp
@@ -10,8 +10,8 @@
  */
 
 #include <boost/random/ranlux.hpp>
-#include <boost/cstdint.hpp>
 #include <cmath>
+#include <cstdint>
 
 #define BOOST_RANDOM_URNG boost::random::ranlux64_4
 
diff --git a/test/test_seed_seq.cpp b/test/test_seed_seq.cpp
index c241d8027..b600b3695 100644
--- a/test/test_seed_seq.cpp
+++ b/test/test_seed_seq.cpp
@@ -9,21 +9,18 @@
  */
 
 #include <boost/random/seed_seq.hpp>
-#include <boost/assign/list_of.hpp>
 #include <boost/config.hpp>
 #include <vector>
 
 #define BOOST_TEST_MAIN
 #include <boost/test/unit_test.hpp>
 
-using boost::assign::list_of;
-
 BOOST_AUTO_TEST_CASE(test_seed_seq) {
-    boost::uint32_t expected_param[4] = { 2, 3, 4, 0xdeadbeaf };
-    boost::uint32_t param[4] = { 2, 3, 4, 0xdeadbeaf };
-    boost::uint32_t store32[10];
-    boost::uint64_t store64[10];
-    boost::uint32_t expected[10] = {
+    std::uint32_t expected_param[4] = { 2, 3, 4, 0xdeadbeaf };
+    std::uint32_t param[4] = { 2, 3, 4, 0xdeadbeaf };
+    std::uint32_t store32[10];
+    std::uint64_t store64[10];
+    std::uint32_t expected[10] = {
         3155793538u,
         2047427591u,
         2886057794u,
@@ -44,12 +41,12 @@ BOOST_AUTO_TEST_CASE(test_seed_seq) {
     seq.generate(&store64[0], &store64[0] + 10);
     BOOST_CHECK_EQUAL_COLLECTIONS(
         &store64[0], &store64[0] + 10, &expected[0], &expected[0] + 10);
-    BOOST_CHECK_EQUAL(seq.size(), 0u);
+    BOOST_TEST(seq.size() == 0u);
     seq.param(&param[0]);
     BOOST_CHECK_EQUAL_COLLECTIONS(
         &param[0], &param[0] + 4, &expected_param[0], &expected_param[0] + 4);
 
-    boost::uint32_t expected_r[10] = {
+    std::uint32_t expected_r[10] = {
         2681148375u,
         3302224839u,
         249244011u,
@@ -62,7 +59,7 @@ BOOST_AUTO_TEST_CASE(test_seed_seq) {
         494552679u
     };
 
-    std::vector<int> data = list_of(2)(3)(4);
+    std::vector<int> data{ 2, 3, 4 };
     
     std::fill_n(&store32[0], 10, 0);
     std::fill_n(&store64[0], 10, 0);
@@ -74,7 +71,7 @@ BOOST_AUTO_TEST_CASE(test_seed_seq) {
     seq_r.generate(&store64[0], &store64[0] + 10);
     BOOST_CHECK_EQUAL_COLLECTIONS(
         &store64[0], &store64[0] + 10, &expected_r[0], &expected_r[0] + 10);
-    BOOST_CHECK_EQUAL(seq_r.size(), 3u);
+    BOOST_TEST(seq_r.size() == 3u);
     seq_r.param(&param[0]);
     BOOST_CHECK_EQUAL_COLLECTIONS(
         &param[0], &param[0] + 4, &expected_param[0], &expected_param[0] + 4);
@@ -89,7 +86,7 @@ BOOST_AUTO_TEST_CASE(test_seed_seq) {
     seq_it.generate(&store64[0], &store64[0] + 10);
     BOOST_CHECK_EQUAL_COLLECTIONS(
         &store64[0], &store64[0] + 10, &expected_r[0], &expected_r[0] + 10);
-    BOOST_CHECK_EQUAL(seq_it.size(), 3u);
+    BOOST_TEST(seq_it.size() == 3u);
     seq_it.param(&param[0]);
     BOOST_CHECK_EQUAL_COLLECTIONS(
         &param[0], &param[0] + 4, &expected_param[0], &expected_param[0] + 4);
@@ -105,7 +102,7 @@ BOOST_AUTO_TEST_CASE(test_seed_seq) {
     seq_il.generate(&store64[0], &store64[0] + 10);
     BOOST_CHECK_EQUAL_COLLECTIONS(
         &store64[0], &store64[0] + 10, &expected_r[0], &expected_r[0] + 10);
-    BOOST_CHECK_EQUAL(seq_il.size(), 3u);
+    BOOST_TEST(seq_il.size() == 3u);
     seq_il.param(&param[0]);
     BOOST_CHECK_EQUAL_COLLECTIONS(
         &param[0], &param[0] + 4, &expected_param[0], &expected_param[0] + 4);
@@ -113,14 +110,14 @@ BOOST_AUTO_TEST_CASE(test_seed_seq) {
 }
 
 BOOST_AUTO_TEST_CASE(test_seed_seq_short_output) {
-    boost::uint32_t store32[2];
+    std::uint32_t store32[2];
 
-    boost::uint32_t expected_short[2] = {
+    std::uint32_t expected_short[2] = {
         4149590228u,
         3175758659u
     };
     
-    std::vector<int> data = list_of(2)(3)(4)(5);
+    std::vector<int> data{ 2, 3, 4, 5 };
 
     boost::random::seed_seq seq(data);
 
diff --git a/test/test_triangle_distribution.cpp b/test/test_triangle_distribution.cpp
index 32ded62c2..de557f46e 100644
--- a/test/test_triangle_distribution.cpp
+++ b/test/test_triangle_distribution.cpp
@@ -10,7 +10,6 @@
  */
 
 #include <boost/random/triangle_distribution.hpp>
-#include <limits>
 
 #define BOOST_RANDOM_DISTRIBUTION boost::random::triangle_distribution<>
 #define BOOST_RANDOM_ARG1 a
diff --git a/test/test_uniform_int.ipp b/test/test_uniform_int.ipp
index fe35c39a2..8db6c43ee 100644
--- a/test/test_uniform_int.ipp
+++ b/test/test_uniform_int.ipp
@@ -9,12 +9,12 @@
  * $Id$
  */
 
+#include <cstdint>
 #include <numeric>
+#include <limits>
 #include <sstream>
 #include <vector>
 #include <boost/config.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/limits.hpp>
 #include <boost/random/mersenne_twister.hpp>
 #include <boost/random/linear_congruential.hpp>
 #include <boost/random/lagged_fibonacci.hpp>
@@ -31,15 +31,15 @@ void check_uniform_int(Generator & gen, int iter)
     std::vector<int> bucket(range);
     for(int j = 0; j < iter; j++) {
         int result = gen();
-        BOOST_CHECK_GE(result, (gen.min)());
-        BOOST_CHECK_LE(result, (gen.max)());
+        BOOST_TEST(result >= (gen.min)());
+        BOOST_TEST(result <= (gen.max)());
         if(result >= (gen.min)() && result <= (gen.max)()) {
             bucket[result-(gen.min)()]++;
         }
     }
     int sum = std::accumulate(bucket.begin(), bucket.end(), 0);
     std::vector<double> expected(range, 1.0 / range);
-    BOOST_CHECK_LT(chi_squared_test(bucket, expected, sum), 0.99);
+    BOOST_TEST(chi_squared_test(bucket, expected, sum) < 0.99);
 }
 
 BOOST_AUTO_TEST_CASE(test_uniform_int)
@@ -77,7 +77,7 @@ BOOST_AUTO_TEST_CASE(test_uniform_int)
     level_three uint1_4(uint05, int_gen(1, 4));
     check_uniform_int(uint1_4, 100000);
 
-    typedef BOOST_RANDOM_UNIFORM_INT<boost::uint8_t> int8_gen;
+    typedef BOOST_RANDOM_UNIFORM_INT<std::uint8_t> int8_gen;
     typedef boost::random::variate_generator<boost::random::mt19937&, int8_gen> gen8_t;
 
     gen8_t gen8_03(gen, int8_gen(0, 3));
@@ -107,7 +107,7 @@ class ruetti_gen
 {
 public:
     ruetti_gen() : state((max)() - 1) {}
-    typedef boost::uint64_t result_type;
+    typedef std::uint64_t result_type;
     result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return 0; }
     result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return std::numeric_limits<result_type>::max BOOST_PREVENT_MACRO_SUBSTITUTION (); }
     result_type operator()() { return state--; }
diff --git a/test/test_uniform_int_distribution.cpp b/test/test_uniform_int_distribution.cpp
index 5863163b0..47a412037 100644
--- a/test/test_uniform_int_distribution.cpp
+++ b/test/test_uniform_int_distribution.cpp
@@ -10,7 +10,6 @@
  */
 
 #include <boost/random/uniform_int_distribution.hpp>
-#include <limits>
 
 #define BOOST_RANDOM_DISTRIBUTION boost::random::uniform_int_distribution<>
 #define BOOST_RANDOM_ARG1 a
diff --git a/test/test_uniform_on_sphere_distribution.cpp b/test/test_uniform_on_sphere_distribution.cpp
index 2b966bccf..397cf48b9 100644
--- a/test/test_uniform_on_sphere_distribution.cpp
+++ b/test/test_uniform_on_sphere_distribution.cpp
@@ -10,19 +10,16 @@
  */
 
 #include <boost/random/uniform_on_sphere.hpp>
-#include <boost/assign/list_of.hpp>
-
-#include <limits>
 
 #define BOOST_RANDOM_DISTRIBUTION boost::random::uniform_on_sphere<>
 #define BOOST_RANDOM_ARG1 dim
 #define BOOST_RANDOM_ARG1_DEFAULT 2
 #define BOOST_RANDOM_ARG1_VALUE 3
 
-std::vector<double> min0 = boost::assign::list_of(-1.0)(0.0);
-std::vector<double> max0 = boost::assign::list_of(1.0)(0.0);
-std::vector<double> min1 = boost::assign::list_of(-1.0)(0.0)(0.0);
-std::vector<double> max1 = boost::assign::list_of(1.0)(0.0)(0.0);
+std::vector<double> min0{ -1.0, 0.0 };
+std::vector<double> max0{ 1.0, 0.0 };
+std::vector<double> min1{ -1.0, 0.0, 0.0 };
+std::vector<double> max1{ 1.0, 0.0, 0.0 };
 
 #define BOOST_RANDOM_DIST0_MIN min0
 #define BOOST_RANDOM_DIST0_MAX max0
@@ -81,7 +78,7 @@ BOOST_AUTO_TEST_CASE(test_valid_output) {
             for(std::size_t j = 0; j < result.size(); ++j) {
                 sum_sq += result[j] * result[j];
             }
-            BOOST_CHECK_CLOSE_FRACTION(sum_sq, 1.0, 1e-5);
+            BOOST_TEST(sum_sq == 1.0, boost::test_tools::tolerance(1e-5));
         }
     }
 }
diff --git a/test/test_uniform_real_distribution.cpp b/test/test_uniform_real_distribution.cpp
index ed47e59e7..ffb80f6e8 100644
--- a/test/test_uniform_real_distribution.cpp
+++ b/test/test_uniform_real_distribution.cpp
@@ -43,6 +43,6 @@ BOOST_AUTO_TEST_CASE(test_dbl_min_max) {
     double max = (std::numeric_limits<double>::max)();
     boost::random::uniform_real_distribution<double> dist(min, max);
     double val = dist(rng);
-    BOOST_CHECK_GE(val, min);
-    BOOST_CHECK_LE(val, max);
+    BOOST_TEST(val >= min);
+    BOOST_TEST(val <= max);
 }
diff --git a/test/test_uniform_smallint_distribution.cpp b/test/test_uniform_smallint_distribution.cpp
index d943ebfb2..b838c5645 100644
--- a/test/test_uniform_smallint_distribution.cpp
+++ b/test/test_uniform_smallint_distribution.cpp
@@ -10,7 +10,6 @@
  */
 
 #include <boost/random/uniform_smallint.hpp>
-#include <limits>
 
 #define BOOST_RANDOM_DISTRIBUTION boost::random::uniform_smallint<>
 #define BOOST_RANDOM_ARG1 a