Remove Boost::geometry from CMakeLists

Add Boost.Geometry to CMakeList.txt
Add Boost.Geometry to b2 dependencies
2026-07-23 13:43:57 +00:00 · 2025-10-28 07:47:13 +09:00 · 2025-10-14 07:44:21 +09:00 · 2025-10-14 07:40:24 +09:00 · 2025-10-09 16:54:49 +09:00 · 2025-10-08 08:58:40 +09:00
167 changed files with 3588 additions and 2171 deletions
@@ -5,6 +5,7 @@ AlignEscapedNewlinesLeft: true
 AlwaysBreakAfterDefinitionReturnType: None
 BreakBeforeBraces: Allman
 BreakConstructorInitializersBeforeComma: false
+BreakTemplateDeclarations: Yes
 ColumnLimit: 80
 ConstructorInitializerAllOnOneLineOrOnePerLine: true
 ConstructorInitializerIndentWidth: 0
@@ -14,67 +14,35 @@ windowsglobalimage="cppalliance/dronevs2019"

 def main(ctx):
  return [
-  linux_cxx("g++-5 11", "g++-5", packages="g++-5", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-5', 'CXXSTD': '11', }, globalenv=globalenv),
-  linux_cxx("g++-5 14", "g++-5", packages="g++-5", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-5', 'CXXSTD': '14', }, globalenv=globalenv),
-  linux_cxx("g++-5 1z", "g++-5", packages="g++-5", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-5', 'CXXSTD': '1z', }, globalenv=globalenv),
-  
-  linux_cxx("g++-6 11", "g++-6", packages="g++-6", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': '11', }, globalenv=globalenv),
-  linux_cxx("g++-6 14", "g++-6", packages="g++-6", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': '14', }, globalenv=globalenv),
-  linux_cxx("g++-6 1z", "g++-6", packages="g++-6", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-6', 'CXXSTD': '1z', }, globalenv=globalenv),
-
-  linux_cxx("g++-7 11", "g++-7", packages="g++-7", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-7', 'CXXSTD': '11', }, globalenv=globalenv),
  linux_cxx("g++-7 14", "g++-7", packages="g++-7", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-7', 'CXXSTD': '14', }, globalenv=globalenv),
  linux_cxx("g++-7 17", "g++-7", packages="g++-7", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-7', 'CXXSTD': '17', }, globalenv=globalenv),

-  linux_cxx("g++-8 11", "g++-8", packages="g++-8", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': '11', }, globalenv=globalenv),
  linux_cxx("g++-8 14", "g++-8", packages="g++-8", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': '14', }, globalenv=globalenv),
  linux_cxx("g++-8 17", "g++-8", packages="g++-8", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': '17', }, globalenv=globalenv),

-  linux_cxx("g++-9 11", "g++-9", packages="g++-9", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': '11', }, globalenv=globalenv),
  linux_cxx("g++-9 14", "g++-9", packages="g++-9", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': '14', }, globalenv=globalenv),
  linux_cxx("g++-9 17", "g++-9", packages="g++-9", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': '17', }, globalenv=globalenv),
  linux_cxx("g++-9 2a", "g++-9", packages="g++-9", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': '2a', }, globalenv=globalenv),

-  linux_cxx("g++-10 11", "g++-10", packages="g++-10", image="cppalliance/droneubuntu2004:1", buildtype="boost", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': '11', }, globalenv=globalenv),
  linux_cxx("g++-10 14", "g++-10", packages="g++-10", image="cppalliance/droneubuntu2004:1", buildtype="boost", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': '14', }, globalenv=globalenv),
  linux_cxx("g++-10 17", "g++-10", packages="g++-10", image="cppalliance/droneubuntu2004:1", buildtype="boost", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': '17', }, globalenv=globalenv),
  linux_cxx("g++-10 20", "g++-10", packages="g++-10", image="cppalliance/droneubuntu2004:1", buildtype="boost", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': '20', }, globalenv=globalenv),
-
-  linux_cxx("clang++-4.0 11", "clang++-4.0", packages="clang-4.0", llvm_os="xenial", llvm_ver="4.0", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-4.0', 'CXXSTD': '11', }, globalenv=globalenv),
-  linux_cxx("clang++-4.0 14", "clang++-4.0", packages="clang-4.0", llvm_os="xenial", llvm_ver="4.0", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-4.0', 'CXXSTD': '14', }, globalenv=globalenv),
-  linux_cxx("clang++-4.0 1z", "clang++-4.0", packages="clang-4.0", llvm_os="xenial", llvm_ver="4.0", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-4.0', 'CXXSTD': '1z', }, globalenv=globalenv),
-
-  linux_cxx("clang++-5.0 11", "clang++-5.0", packages="clang-5.0", llvm_os="xenial", llvm_ver="5.0", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-5.0', 'CXXSTD': '11', }, globalenv=globalenv),
-  linux_cxx("clang++-5.0 14", "clang++-5.0", packages="clang-5.0", llvm_os="xenial", llvm_ver="5.0", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-5.0', 'CXXSTD': '14', }, globalenv=globalenv),
-  linux_cxx("clang++-5.0 1z", "clang++-5.0", packages="clang-5.0", llvm_os="xenial", llvm_ver="5.0", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-5.0', 'CXXSTD': '1z', }, globalenv=globalenv),
-
-  linux_cxx("clang++-6.0 11", "clang++-6.0", packages="clang-6.0", llvm_os="xenial", llvm_ver="6.0", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-6.0', 'CXXSTD': '11', }, globalenv=globalenv),
-  linux_cxx("clang++-6.0 14", "clang++-6.0", packages="clang-6.0", llvm_os="xenial", llvm_ver="6.0", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-6.0', 'CXXSTD': '14', }, globalenv=globalenv),
-  linux_cxx("clang++-6.0 1z", "clang++-6.0", packages="clang-6.0", llvm_os="xenial", llvm_ver="6.0", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-6.0', 'CXXSTD': '1z', }, globalenv=globalenv),
-
-  linux_cxx("clang++-7 14", "clang++-7", packages="clang-7", llvm_os="xenial", llvm_ver="7", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-7', 'CXXSTD': '11', }, globalenv=globalenv),
-  linux_cxx("clang++-7 17", "clang++-7", packages="clang-7", llvm_os="xenial", llvm_ver="7", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-7', 'CXXSTD': '14', }, globalenv=globalenv),
-  linux_cxx("clang++-7 1z", "clang++-7", packages="clang-7", llvm_os="xenial", llvm_ver="7", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-7', 'CXXSTD': '1z', }, globalenv=globalenv),
-
-  linux_cxx("clang++-8 11", "clang++-8", packages="clang-8", llvm_os="xenial", llvm_ver="8", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-8', 'CXXSTD': '11', }, globalenv=globalenv),
+  
+  linux_cxx("clang++-7 14", "clang++-7", packages="clang-7", llvm_os="xenial", llvm_ver="7", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-7', 'CXXSTD': '14', }, globalenv=globalenv),
+  linux_cxx("clang++-7 17", "clang++-7", packages="clang-7", llvm_os="xenial", llvm_ver="7", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-7', 'CXXSTD': '17', }, globalenv=globalenv),
+  
  linux_cxx("clang++-8 14", "clang++-8", packages="clang-8", llvm_os="xenial", llvm_ver="8", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-8', 'CXXSTD': '14', }, globalenv=globalenv),
  linux_cxx("clang++-8 17", "clang++-8", packages="clang-8", llvm_os="xenial", llvm_ver="8", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-8', 'CXXSTD': '17', }, globalenv=globalenv),
-  linux_cxx("clang++-8 2a", "clang++-8", packages="clang-8", llvm_os="xenial", llvm_ver="8", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-8', 'CXXSTD': '2a', }, globalenv=globalenv),

-  linux_cxx("clang++-9 11", "clang++-9", packages="clang-9", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': '11', }, globalenv=globalenv),
  linux_cxx("clang++-9 14", "clang++-9", packages="clang-9", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': '14', }, globalenv=globalenv),
  linux_cxx("clang++-9 17", "clang++-9", packages="clang-9", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': '17', }, globalenv=globalenv),
-  linux_cxx("clang++-9 2a", "clang++-9", packages="clang-9", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': '2a', }, globalenv=globalenv),

-  linux_cxx("clang++-10 11", "clang++-10", packages="clang-10", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': '11', }, globalenv=globalenv),
  linux_cxx("clang++-10 14", "clang++-10", packages="clang-10", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': '14', }, globalenv=globalenv),
  linux_cxx("clang++-10 17", "clang++-10", packages="clang-10", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': '17', }, globalenv=globalenv),
  linux_cxx("clang++-10 20", "clang++-10", packages="clang-10", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': '20', }, globalenv=globalenv),

-  osx_cxx("XCode-11.7 11", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '11', }, globalenv=globalenv),
  osx_cxx("XCode-11.7 14", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '14', }, globalenv=globalenv),
  osx_cxx("XCode-11.7 17", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '17', }, globalenv=globalenv),
-  osx_cxx("XCode-11.7 2a", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '2a', }, globalenv=globalenv),
  ]

 # from https://github.com/boostorg/boost-ci
@@ -7,16 +7,15 @@
 name: CI
 on: [ push, pull_request ]
 jobs:
-  ubuntu-focal:
-    runs-on: ubuntu-20.04
+  ubuntu:
+    runs-on: ubuntu-24.04
    strategy:
      fail-fast: false
      matrix:
-      # Removed g++-10 because of an ICE; meant to be fixed in 10.2?
-      # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=94938
-        compiler: [ g++-9, clang++-10 ]
+        compiler: [ gcc-14, clang-19 ]
+        cxxstd: [ 14, 17, 20, 23 ]
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@master
        with:
          fetch-depth: '0'
      - uses: mstachniuk/ci-skip@v1
@@ -24,12 +23,12 @@ jobs:
          commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[windows];[Windows];[WINDOWS];[apple];[Apple];[APPLE]'
          commit-filter-separator: ';'
          fail-fast: true
-      - name: Set TOOLSET
-        run: echo ${{ matrix.compiler }} | awk '/^g/ { print "TOOLSET=gcc" } /^clang/ { print "TOOLSET=clang" }' >> $GITHUB_ENV
-      - name: Add repository
-        run: sudo apt-add-repository -y "ppa:ubuntu-toolchain-r/test"
+      - name: Set ENV
+        run: |
+          echo ${{ matrix.compiler }} | awk '/^gcc/ { print "TOOLSET=gcc" } /^clang/ { print "TOOLSET=clang" }' >> $GITHUB_ENV
+          echo ${{ matrix.compiler }} | awk '/^gcc/ { gsub(/gcc/,"CXX=g++"); print; } /^clang/ { gsub(/clang/,"CXX=clang++"); print; }' >> $GITHUB_ENV
      - name: Install packages
-        run: sudo apt install g++-9 clang-10
+        run: sudo apt install ${{ matrix.compiler }}
      - name: Checkout main boost
        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
      - name: Update tools/boostdep
@@ -48,13 +47,13 @@ jobs:
        run: ./b2 headers
        working-directory: ../boost-root
      - name: Generate user config
-        run: 'echo "using $TOOLSET : : ${{ matrix.compiler }} ;" > ~/user-config.jam'
+        run: 'echo "using $TOOLSET : : $CXX ;" > ~/user-config.jam'
        working-directory: ../boost-root
      - name: Config info
-        run: ../../../b2 print_config_info toolset=$TOOLSET cxxstd=11,14,17,2a
+        run: ../../../b2 print_config_info toolset=$TOOLSET cxxstd=${{ matrix.cxxstd }}
        working-directory: ../boost-root/libs/config/test
      - name: Test
-        run: ../../../b2 toolset=$TOOLSET cxxstd=11,14,17,2a
+        run: ../../../b2 toolset=$TOOLSET cxxstd=${{ matrix.cxxstd }}
        working-directory: ../boost-root/libs/graph/test
  macos:
    runs-on: macos-latest
@@ -62,8 +61,9 @@ jobs:
      fail-fast: false
      matrix:
        toolset: [ clang ]
+        cxxstd: [ 14, 17, 20 ]
    steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@master
        with:
          fetch-depth: '0'
      - uses: mstachniuk/ci-skip@v1
@@ -89,51 +89,10 @@ jobs:
        run: ./b2 headers
        working-directory: ../boost-root
      - name: Config info
-        run: ../../../b2 print_config_info toolset=${{ matrix.toolset }} cxxstd=11,14,17,2a
+        run: ../../../b2 print_config_info toolset=${{ matrix.toolset }} cxxstd=${{ matrix.cxxstd }}
        working-directory: ../boost-root/libs/config/test
      - name: Test
-        run: ../../../b2 toolset=${{ matrix.toolset }} cxxstd=11,14,17,2a define=CI_SUPPRESS_KNOWN_ISSUES
-        working-directory: ../boost-root/libs/graph/test
-  windows_msvc_14_2:
-    runs-on: windows-2019
-    defaults:
-      run:
-        shell: cmd
-    strategy:
-      fail-fast: false
-      matrix:
-        toolset: [ msvc-14.2 ]
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          fetch-depth: '0'
-      - uses: mstachniuk/ci-skip@v1
-        with:
-          commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[apple];[Apple];[APPLE];[linux];[Linux];[LINUX]'
-          commit-filter-separator: ';'
-          fail-fast: true
-      - name: Checkout main boost
-        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
-      - name: Update tools/boostdep
-        run: git submodule update --init tools/boostdep
-        working-directory: ../boost-root
-      - name: Copy files
-        run: xcopy /s /e /q %GITHUB_WORKSPACE% libs\graph
-        working-directory: ../boost-root
-      - name: Install deps
-        run: python tools/boostdep/depinst/depinst.py graph
-        working-directory: ../boost-root
-      - name: Bootstrap
-        run: bootstrap
-        working-directory: ../boost-root
-      - name: Generate headers
-        run: b2 headers
-        working-directory: ../boost-root
-      - name: Config info
-        run: ..\..\..\b2 print_config_info cxxstd=14,17,20 address-model=64 toolset=msvc-14.2
-        working-directory: ../boost-root/libs/config/test
-      - name: Test
-        run: ..\..\..\b2 --hash address-model=64 cxxstd=14,17,20 toolset=msvc-14.2
+        run: ../../../b2 toolset=${{ matrix.toolset }} cxxstd=${{ matrix.cxxstd }} define=CI_SUPPRESS_KNOWN_ISSUES
        working-directory: ../boost-root/libs/graph/test
  windows_msvc_14_3:
    runs-on: windows-2022
@@ -176,3 +135,223 @@ jobs:
      - name: Test
        run: ..\..\..\b2 --hash address-model=64 cxxstd=14,17,20 toolset=msvc-14.3
        working-directory: ../boost-root/libs/graph/test
+
+  posix-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-22.04
+          - os: ubuntu-24.04
+          - os: macos-14
+          - os: macos-15
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - 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
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Use library with add_subdirectory
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  posix-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-22.04
+          - os: ubuntu-24.04
+          - os: macos-14
+          - os: macos-15
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - 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
+          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 -DCMAKE_INSTALL_PREFIX=~/.local ..
+
+      - name: Install
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install
+
+      - name: Use the installed library
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  windows-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2022
+          - os: windows-2025
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - 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%
+
+      - name: Use library with add_subdirectory (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use library with add_subdirectory (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release
+
+  windows-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2022
+          - os: windows-2025
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - 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%
+
+      - name: Configure
+        shell: cmd
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+
+      - name: Install (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install --config Debug
+
+      - name: Install (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install --config Release
+
+      - name: Use the installed library (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use the installed library (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release
@@ -2,7 +2,7 @@
 # Distributed under the Boost Software License, Version 1.0.
 # https://www.boost.org/LICENSE_1_0.txt

-cmake_minimum_required(VERSION 3.5...3.16)
+cmake_minimum_required(VERSION 3.8...3.16)

 project(boost_graph VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)

@@ -22,7 +22,6 @@ target_link_libraries(boost_graph
    Boost::array
    Boost::assert
    Boost::bimap
-    Boost::bind
    Boost::concept_check
    Boost::config
    Boost::container_hash
@@ -1,4 +1,4 @@
-Boost Graph Library  [![Build Status](https://drone.cpp.al/api/badges/boostorg/graph/status.svg)](https://drone.cpp.al/boostorg/graph)[![Build Status](https://github.com/boostorg/graph/workflows/CI/badge.svg?branch=develop)](https://github.com/boostorg/graph/actions)
+# Boost Graph Library

 ===================

@@ -6,7 +6,7 @@ A generic interface for traversing graphs, using C++ templates.

 The full documentation is available on [boost.org](http://www.boost.org/doc/libs/release/libs/graph/doc/index.html).

-## Support, bugs and feature requests ##
+## Support, bugs and feature requests

 Bugs and feature requests can be reported through the [Github issue page](https://github.com/boostorg/graph/issues).

@@ -22,13 +22,15 @@ You can submit your changes through a [pull request](https://github.com/boostorg
 There is no mailing-list specific to Boost Graph, although you can use the general-purpose Boost [mailing-list](http://lists.boost.org/mailman/listinfo.cgi/boost-users) using the tag [graph].


-## Development ##
+### Build Status

 |                  |  Master  |   Develop   |
 |------------------|----------|-------------|
-| Github Actions | [![Build Status](https://github.com/boostorg/graph/workflows/CI/badge.svg?branch=master)](https://github.com/boostorg/graph/actions) | [![Build Status](https://github.com/boostorg/graph/workflows/CI/badge.svg?branch=develop)](https://github.com/boostorg/graph/actions) |
+| Github Actions | [![Build Status](https://github.com/boostorg/graph/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/boostorg/graph/actions) | [![Build Status](https://github.com/boostorg/graph/actions/workflows/ci.yml/badge.svg?branch=develop)](https://github.com/boostorg/graph/actions) |
 |Drone | [![Build Status](https://drone.cpp.al/api/badges/boostorg/graph/status.svg?ref=refs/heads/master)](https://drone.cpp.al/boostorg/graph) | [![Build Status](https://drone.cpp.al/api/badges/boostorg/graph/status.svg)](https:/drone.cpp.al/boostorg/graph) |

+## Development
+
 Clone the whole boost project, which includes the individual Boost projects as submodules ([see boost+git doc](https://github.com/boostorg/boost/wiki/Getting-Started)):

    git clone https://github.com/boostorg/boost
@@ -45,7 +47,7 @@ Boost Graph Library is mostly made of headers but also contains some compiled co

 **Note:** The Boost Graph Library cannot currently be built outside of Boost itself.

-### Running tests ###
+### Running tests
 First, make sure you are in `libs/graph/test`.
 You can either run all the 300+ tests listed in `Jamfile.v2` or run a single test:

@@ -0,0 +1,62 @@
+# Copyright René Ferdinand Rivera Morell 2024
+# 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)
+
+require-b2 5.2 ;
+
+constant boost_dependencies :
+    /boost/algorithm//boost_algorithm
+    /boost/any//boost_any
+    /boost/array//boost_array
+    /boost/assert//boost_assert
+    /boost/bimap//boost_bimap
+    /boost/bind//boost_bind
+    /boost/concept_check//boost_concept_check
+    /boost/config//boost_config
+    /boost/container_hash//boost_container_hash
+    /boost/conversion//boost_conversion
+    /boost/core//boost_core
+    /boost/detail//boost_detail
+    /boost/foreach//boost_foreach
+    /boost/function//boost_function
+    /boost/geometry//boost_geometry
+    /boost/integer//boost_integer
+    /boost/iterator//boost_iterator
+    /boost/lexical_cast//boost_lexical_cast
+    /boost/math//boost_math_tr1
+    /boost/move//boost_move
+    /boost/mpl//boost_mpl
+    /boost/multi_index//boost_multi_index
+    /boost/optional//boost_optional
+    /boost/parameter//boost_parameter
+    /boost/preprocessor//boost_preprocessor
+    /boost/property_map//boost_property_map
+    /boost/property_tree//boost_property_tree
+    /boost/random//boost_random
+    /boost/range//boost_range
+    /boost/serialization//boost_serialization
+    /boost/smart_ptr//boost_smart_ptr
+    /boost/spirit//boost_spirit
+    /boost/static_assert//boost_static_assert
+    /boost/throw_exception//boost_throw_exception
+    /boost/tti//boost_tti
+    /boost/tuple//boost_tuple
+    /boost/type_traits//boost_type_traits
+    /boost/typeof//boost_typeof
+    /boost/unordered//boost_unordered
+    /boost/utility//boost_utility
+    /boost/xpressive//boost_xpressive ;
+
+project /boost/graph
+    ;
+
+explicit
+    [ alias boost_graph : build//boost_graph ]
+    [ alias all : boost_graph example test ]
+    ;
+
+call-if : boost-library graph
+    : install boost_graph
+    ;
+
@@ -6,9 +6,15 @@

 import mpi ;

-project boost/graph
-    : requirements <include>../src
+constant boost_dependencies_private :
+    /boost/regex//boost_regex
+    ;
+
+project
+    : common-requirements <include>../include <library>$(boost_dependencies)
+    : requirements <include>../src <library>$(boost_dependencies_private)
    : source-location ../src
+    : usage-requirements <define>BOOST_GRAPH_NO_LIB=1
    ;

 lib boost_graph
@@ -24,5 +30,3 @@ lib boost_graph
    :
    :
    ;
-
-boost-install boost_graph ;
@@ -453,6 +453,11 @@ Journal of the ACM (JACM), 23(2): 221-234, 1976.
 <em>Data Structures for Weighted Matching and Nearest Common Ancestors with Linking</em><br>
 Proceedings of the First Annual ACM-SIAM Symposium on Discrete Algorithms, pp. 434-443, 1990.

+<p></p><dt><a name="galil86">77</a>
+<dd>Zvi Galil<br>
+<em><a href="https://dl.acm.org/doi/pdf/10.1145/6462.6502">Efficient Algorithms for Finding Maximum Matching in Graphs</a></em><br>
+ACM Computing Surveys (CSUR), 18(1), 23-38, 1986.
+
 </dl>

 <br>
@@ -169,7 +169,7 @@ disjoint_sets&lt;Rank, Parent, FindCompress&gt;
  very slowly, much more slowly than the <i>log</i> function.</p>

  <h3>See Also</h3><a href=
-  "../graph/doc/incremental_components.html"><tt>incremental_connected_components()</tt></a>
+  "incremental_components.html"><tt>incremental_connected_components()</tt></a>
  <hr>
  <pre>
 disjoint_sets_with_storage&lt;ID,InverseID,FindCompress&gt;
@@ -181,7 +181,7 @@ disjoint_sets_with_storage&lt;ID,InverseID,FindCompress&gt;
  The rank and parent properties are initialized during construction so the
  each element is in a set by itself (so it is not necessary to initialize
  objects of this class with the <a href=
-  "../graph/doc/incremental_components.html#sec:initialize-incremental-components">
+  "incremental_components.html#sec:initialize-incremental-components">
  <tt>initialize_incremental_components()</tt></a> function). This class is
  especially useful when computing the (dynamic) connected components of an
  <tt>edge_list</tt> graph which does not provide a place to store vertex
@@ -69,7 +69,7 @@
    <p>
      Defined in
      <a href="../../../boost/graph/grid_graph.hpp"><tt>boost/graph/grid_graph.hpp</tt></a>
-      with all functions in the <tt>boost</tt> namespace.  A simple examples of creating and iterating over a grid_graph is available here <a href="../../../libs/graph/example/grid_graph_example.cpp"><tt>libs/graph/example/grid_graph_example.cpp</tt></a>. An example of adding properties to a grid_graph is also available <a href="../../../libs/graph/example/grid_graph_example.cpp"><tt>libs/graph/example/grid_graph_properties.cpp</tt></a>
+      with all functions in the <tt>boost</tt> namespace.  A simple examples of creating and iterating over a grid_graph is available here <a href="../../../libs/graph/example/grid_graph_example.cpp"><tt>libs/graph/example/grid_graph_example.cpp</tt></a>. An example of adding properties to a grid_graph is also available <a href="../../../libs/graph/example/grid_graph_properties.cpp"><tt>libs/graph/example/grid_graph_properties.cpp</tt></a>
    </p>

    <h4>Template Parameters</h4>
@@ -43,7 +43,7 @@ the situation where edges are both added and removed from the graph,
 hence it is called <b><i>incremental</i></b><a
 href="bibliography.html#eppstein97:dynamic_graph">[42]</a> (and not
 fully dynamic). The disjoint-sets class is described in Section <A
-HREF="../../disjoint_sets/disjoint_sets.html">Disjoint Sets</A>.
+HREF="disjoint_sets.html">Disjoint Sets</A>.

 <P>
 The following five operations are the primary functions that you will
@@ -1,5 +1,6 @@
 <html><head><!--
     Copyright 2018 Yi Ji
+     Copyright 2025 Joris van Rantwijk

     Use, modification and distribution is subject to the Boost Software
     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -20,6 +21,9 @@ void maximum_weighted_matching(const Graph&amp; g, MateMap mate);
 template &lt;typename Graph, typename MateMap, typename VertexIndexMap&gt;
 void maximum_weighted_matching(const Graph&amp; g, MateMap mate, VertexIndexMap vm);

+template &lt;typename Graph, typename MateMap, typename VertexIndexMap, typename EdgeWeightMap&gt;
+void maximum_weighted_matching(const Graph&amp; g, MateMap mate, VertexIndexMap vm, EdgeWeightMap weights);
+
 template &lt;typename Graph, typename MateMap&gt;
 void brute_force_maximum_weighted_matching(const Graph&amp; g, MateMap mate);

@@ -56,77 +60,126 @@ maximum weighted matching in any undirected graph. The matching is returned in a
 <a href="../../property_map/doc/ReadWritePropertyMap.html">ReadWritePropertyMap</a>
 that maps vertices to vertices. In the mapping returned, each vertex is either mapped
 to the vertex it's matched to, or to <tt>graph_traits&lt;Graph&gt;::null_vertex()</tt> if it
-doesn't participate in the matching. If no <tt>VertexIndexMap</tt> is provided, both functions
-assume that the <tt>VertexIndexMap</tt> is provided as an internal graph property accessible
-by calling <tt>get(vertex_index, g)</tt>.
+doesn't participate in the matching.
+</p>
+
+<h3>Algorithm Description</h3>

 <p>
-The maximum weighted matching problem was solved by Edmonds in [<a href="bibliography.html#edmonds65:_max_weighted_match">74</a>].
-The implementation of <tt>maximum_weighted_matching</tt> followed Chapter 6, Section 10 of [<a href="bibliography.html#lawler76:_comb_opt">20</a>] and
-was written in a consistent style with <tt>edmonds_maximum_cardinality_matching</tt> because of their algorithmic similarity.
-In addition, a brute-force verifier <tt>brute_force_maximum_weighted_matching</tt> simply searches all possible matchings in any graph and selects one with the maximum weight sum.
-
-</p><h3>Algorithm Description</h3>
-
-Primal-dual method in linear programming is introduced to solve weighted matching problems. Edmonds proved that for any graph,
-the maximum number of edges in a matching is equal to the minimum capacity of an odd-set cover; this further enable us to prove a max-min duality theorem for weighted matching.
-Let <i>H<sub>k-1</sub></i> denote any graph obtained from G by contracting odd sets of three or more nodes and deleting single nodes,
-where the capacity of the family of odd sets (not necessarily a cover of G) is <i>k-1</i>. Let <i>X<sub>k</sub></i> denote any matching containing <i>k</i> edges.
-Each edge <i>(i, j)</i> has a weight <i>w<sub>ij</sub></i>. We have:
-<math>
-max<i><sub>X<sub>k</sub></sub></i> min {<i>w<sub>ij</sub>|(i, j) ϵ X<sub>k</sub></i>} = min<i><sub>H<sub>k-1</sub></sub></i> max {<i>w<sub>ij</sub>|(i, j) ϵ H<sub>k-1</sub></i>}.
-</math>
-This matching duality theorem gives an indication of how the matching problem should be formulated as a linear programming problem. That is,
-the theorem suggests a set of linear inequalities which are satisfied by any matching, and it is anticipated that these inequalities describe a convex polyhedron
-with integer vertices corresponding to feasible matchings.
+The maximum weighted matching problem was solved by Edmonds in
+[<a href="bibliography.html#edmonds65:_max_weighted_match">74</a>].
+Subsequently, Gabow [<a href="bibliography.html#gabow76">75</a>] and
+Lawler [<a href="bibliography.html#lawler76:_comb_opt">20</a>] developed methods
+to reduce the run time from <i>O(V<sup>4</sup>)</i> to <i>O(V<sup>3</sup>)</i>.
+The implementation of <tt>maximum_weighted_matching</tt> follows a description
+of the <i>O(V<sup>3</sup>)</i> algorithm by Galil [<a href="bibliography.html#galil86">77</a>].
+</p>

 <p>
-For <tt>maximum_weighted_matching</tt>, the management of blossoms is much more involved than in the case of <tt>max_cardinality_matching</tt>.
-It is not sufficient to record only the outermost blossoms. When an outermost blossom is expanded,
-it is necessary to know which blossom are nested immediately with it, so that these blossoms can be restored to the status of the outermost blossoms.
-When augmentation occurs, blossoms with strictly positive dual variables must be maintained for use in the next application of the labeling procedure.
+Starting from an empty matching, the algorithm repeatedly augments the matching until no further improvement is possible.
+Alternating trees and blossoms are used to find an augmenting path, in a way that is similar to maximum cardinality matching.
+A linear programming technique is used to ensure that the selected augmenting path has maximum weight.
+This involves assigning dual variables to vertices and blossoms, and computing slack values for edges.
+</p>

 <p>
-The outline of the algorithm is as follow:
+The outline of the algorithm is as follows:
+</p>

 <ol start="0">
-<li>Start with an empty matching and initialize dual variables as a half of maximum edge weight.</li>
-<li>(Labeling) Root an alternate tree at each exposed node, and proceed to construct alternate trees by labeling, using only edges with zero slack value.
+<li>Start with an empty matching and initialize dual variables to half of the maximum edge weight.</li>
+<li>(Labeling) Root a tree at each non-matched vertex, and proceed to construct alternating trees by labeling, using only edges with zero slack value.
 If an augmenting path is found, go to step 2. If a blossom is formed, go to step 3. Otherwise, go to step 4. </li>
-<li>(Augmentation) Find the augmenting path, tracing the path through shrunken blossoms. Augment the matching,
-correct labels on nodes in the augmenting path, expand blossoms with zero dual variables and remove labels from all base nodes. Go to step 1.</li>
-<li>(Blossoming) Determine the membership and base node of the new blossom and supply missing labels for all non-base nodes in the blossom.
+<li>(Augmentation) Find the augmenting path, tracing the path through shrunken blossoms. Augment the matching.
+Deconstruct and unlabel the alternating trees traversed by the augmenting path.
+Go to step 1.</li>
+<li>(Blossoming) Identify the blossoms in the alternating cycle and shrink these into a newly formed blossom.
 Return to step 1.</li>
-<li>(Revision of Dual Solution) Adjust the dual variables based on the primal-dual method. Go to step 1 or halt, accordingly.</li>
+<li>(Updating dual variables) Adjust the dual variables based on the primal-dual method.
+If this enables further growth of the alternating trees, return to step 1.
+Otherwise, halt the algorithm; the matching has maximum weight.</li>
 </ol>

-Note that in <tt>maximum_weighted_matching</tt>, all edge weights are multiplied by 4, so that all dual variables always remain as integers if all edge weights are integers.
-Unlike <tt>max_cardinality_matching</tt>, the initial matching and augmenting path finder are not parameterized,
-because the algorithm maintains blossoms, dual variables and node labels across all augmentations.
+<p>
+The implementation deviates from the description in [<a href="bibliography.html#galil86">77</a>] on a few points:
+</p>

-The algorithm's time complexity is reduced from <i>O(V<sup>4</sup>)</i> (naive implementation of [<a href="bibliography.html#edmonds65:_max_weighted_match">74</a>])
-to <i>O(V<sup>3</sup>)</i>, by a delicate labeling procedure [<a href="bibliography.html#gabow76">75</a>] to avoid re-scanning labels after revision of the dual solution.
-Special variables <i>pi, tau, gamma</i> and two arrays <i>critical_edge, tau_idx</i> are introduced for this purpose.
-Please refer to [<a href="bibliography.html#lawler76:_comb_opt">20</a>] and code comments for more implementation details.
+<ul>
+<li>
+After augmenting the matching, [<a href="bibliography.html#galil86">77</a>] expands all blossoms with zero dual.
+This is correct but potentially unnecessary; some of the expanded blossoms will be recreated during the next stage.
+The implementation holds off on the expansion of such blossoms.
+In any scenario where a blossom <i>must</i> be expanded to make progress, label T will be assigned to it.
+At that point, the blossom will be expanded through a zero-delta dual step.
+The additional cost is <i>O(V)</i> per expanded blossom, and the total number of blossom expansions is <i>O(V<sup>2</sup>)</i>,
+therefore this does not change the overall time complexity of the algorithm.
+</li>
+<li>
+The algorithm records a minimum-slack edge <i>e<sub>k,l</sub></i> for every pair of blossoms <i>B<sub>k</sub>, B<sub>l</sub></i>.
+Storing these edges in a 2-dimensional array would increase the space complexity to <i>O(V<sup>2</sup>)</i>;
+an unfortunate cost for large sparse graphs.
+The implementation of <tt>maximum_weighted_matching</tt> avoids this by maintaining, for each blossom <i>B<sub>k</sub></i>,
+a list <tt>B<sub>k</sub>.best_edge_set</tt> that contains the non-empty elements of <i>e<sub>k,l</sub></i>,
+plus edges between <i>B<sub>k</sub></i> and <i>B<sub>l</sub></i> discovered after shrinking <i>B<sub>k</sub></i>.
+The combined length of these lists is <i>O(E)</i>, since any edge is contained in at most two lists.
+The algorithm only ever examines <i>e<sub>k,l</sub></i> during the process of merging <i>B<sub>k</sub></i> into a larger blossom.
+In that case, it sequentially examines <i>e<sub>k,l</sub></i> for all <i>l</i>, taking time <i>O(V)</i>.
+The implementation handles this by examining every element of <tt>B<sub>k</sub>.best_edge_set</tt>,
+taking time <i>O(V)</i> plus a constant time per newly discovered edge.
+This does not change the overall time complexity of the algorithm.
+</li>
+<li>
+After augmenting, [<a href="bibliography.html#galil86">77</a>] removes all labels and alternating trees.
+This keeps the algorithm simple, but it causes many trees and labels to be rediscovered at the beginning of the new stage.
+To avoid such redundent work, <tt>maximum_weighted_matching</tt> removes labels only from the two alternating trees that are touched by the augmenting path.
+All other labels and trees are reused in the next stage.
+Erasing labels from a subset of the graph, requires updating the data structures that track minimum-slack edges.
+This involves examining all edges that either touch a blossom which loses its label or touch a vertex which depended on a lost label.
+These steps take <i>O(V + E)</i> per stage, adding up to <i>O(V<sup>3</sup>)</i> in total.
+Although this strategy does not improve the worst-case time complexity of the algorithm, it achieves a significant speedup in benchmarks on random graphs.
+</li>
+</ul>
+
+<p>
+If edge weights are integers, the algorithm uses only integer computations.
+This is achieved by internally multiplying edge weights by 2, which ensures that all dual variables are also integers.
+</p>
+
+<p>
+A brute-force implementation <tt>brute_force_maximum_weighted_matching</tt> is also provided.
+This algorithm simply searches all possible matchings and selects one with the maximum weight sum.
+</p>

 </p><h3>Where Defined</h3>

 <p>
 <a href="../../../boost/graph/maximum_weighted_matching.hpp"><tt>boost/graph/maximum_weighted_matching.hpp</tt></a>
+</p>

-</p><h3>Parameters</h3>
+<h3>Parameters</h3>

 IN: <tt>const Graph&amp; g</tt>
 <blockquote>
 An undirected graph. The graph type must be a model of
 <a href="VertexAndEdgeListGraph.html">Vertex and Edge List Graph</a> and
 <a href="IncidenceGraph.html">Incidence Graph</a>.
-The edge property of the graph <tt>property_map&lt;Graph, edge_weight_t&gt;</tt> must exist and have numeric value type.<br>
+The graph may not contain parallel edges.
 </blockquote>

 IN: <tt>VertexIndexMap vm</tt>
 <blockquote>
-Must be a model of <a href="../../property_map/doc/ReadablePropertyMap.html">ReadablePropertyMap</a>, mapping vertices to integer indices.
+Must be a model of <a href="../../property_map/doc/ReadablePropertyMap.html">ReadablePropertyMap</a>,
+mapping vertices to integer indices in the range <tt>[0, num_vertices(g))</tt>.
+If this parameter is not explicitly specified, it is obtained from the internal vertex property of the graph
+by calling <tt>get(vertex_index, g)</tt>.
+</blockquote>
+
+IN: <tt>EdgeWeightMap weights</tt>
+<blockquote>
+Must be a model of <a href="../../property_map/doc/ReadablePropertyMap.html">ReadablePropertyMap</a>, mapping edges to weights.
+Edge weights must be integers or floating point values.
+If this parameter is not explicitly specified, it is obtained from the internal edge property of the graph
+by calling <tt>get(edge_weight, g)</tt>.
 </blockquote>

 OUT: <tt>MateMap mate</tt>
@@ -140,24 +193,29 @@ vertices to vertices. For any vertex v in the graph, <tt>get(mate,v)</tt> will b

 <p>
 Let <i>m</i> and <i>n</i> be the number of edges and vertices in the input graph, respectively. Assuming the
-<tt>VertexIndexMap</tt> supplied allows constant-time lookup, the time complexity for
-<tt>maximum_weighted_matching</tt> is <i>O(n<sup>3</sup>)</i>. For <tt>brute_force_maximum_weighted_matching</tt>, the time complexity is exponential of <i>m</i>.
+<tt>VertexIndexMap</tt> and <tt>EdgeWeightMap</tt> both provide constant-time lookup, the time complexity for
+<tt>maximum_weighted_matching</tt> is <i>O(n<sup>3</sup>)</i>.
+For <tt>brute_force_maximum_weighted_matching</tt>, the time complexity is exponential in <i>m</i>.
+</p>
+
+<p>
 Note that the best known time complexity for maximum weighted matching in general graph
 is <i>O(nm+n<sup>2</sup>log(n))</i> by [<a href="bibliography.html#gabow90">76</a>], but relies on an
 efficient algorithm for solving nearest ancestor problem on trees, which is not provided in Boost C++ libraries.
-</p><p>
+</p>

-</p><h3>Example</h3>
+<h3>Example</h3>

-<p> The file <a href="../example/weighted_matching_example.cpp"><tt>example/weighted_matching_example.cpp</tt></a>
+<p>The file <a href="../example/weighted_matching_example.cpp"><tt>example/weighted_matching_example.cpp</tt></a>
 contains an example.
+</p>

-<br>
-</p><hr>
+<hr>
 <table>
 <tbody><tr valign="top">
-<td nowrap="nowrap">Copyright © 2018</td><td>
-Yi Ji (<a href="mailto:jiy@pku.edu.cn">jiy@pku.edu.cn</a>)<br>
+<td nowrap="nowrap">Copyright © 2018, 2025</td><td>
+Yi Ji (<a href="mailto:jiy@pku.edu.cn">jiy@pku.edu.cn</a>),
+Joris van Rantwijk
 </td></tr></tbody></table>

 </body></html>
@@ -19,7 +19,7 @@

 <ul>

-<li><a href="http://www.ddj.com/articles/2000/0009/0009toc.htm">Dr. Dobb's Sept. 2000 Article</a></a></li>
+<li><a href="https://jacobfilipp.com/DrDobbs/articles/DDJ/2000/0009/0009b/0009b.htm">Dr. Dobb's Sept. 2000 Article</a></a></li>
 <li><a href="http://www.acm.org/pubs/citations/proceedings/oops/320384/p399-siek/">OOPSLA'99 GGCL Paper</a></li>
 <li>Lie-Quan Lee's Master's Thesis about GGCL<a href="https://web.archive.org/web/20030824105142/http://www.lsc.nd.edu/downloads/research/ggcl/papers/thesis.ps">(ps)</a> <a href="https://web.archive.org/web/20030824113405/http://www.lsc.nd.edu/downloads/research/ggcl/papers/thesis.pdf">(pdf)</a></li>
 <li><a href="http://www.dietmar-kuehl.de/generic-graph-algorithms.pdf">Dietmar K&uuml;hl's Master's Thesis: Design Pattern for the Implementation of Graph Algorithms</a></li>
@@ -329,6 +329,11 @@ If <tt>vis</tt> is an object of a type modelling the ResourceConstrainedShortest
 <table border>
 <tr>
 <td>
+<tt>vis.on_enter_loop(const Queue&amp; queue, const Graph&amp; g )</tt>
+</td>
+</tr>
+<tr>
+<td>
 <tt>vis.on_label_popped( const Label&amp; l, const Graph&amp; g )</tt>
 </td>
 </tr>
@@ -353,7 +358,7 @@ If <tt>vis</tt> is an object of a type modelling the ResourceConstrainedShortest
 </td>
 </tr>
 </table>
-See the <a href="#Label">description of the Label concept</a> for the interface of a Label. See the <a href="#FunctionsDescription">algorithm description</a> for information on when these functions are called.
+Note that <i>on_enter_loop</i> returns a boolean that signals whether the main loop should continue (see the <i>default_r_c_shortest_paths_visitor</i> in the <a href="../../../boost/graph/r_c_shortest_paths.hpp"><tt>source code</tt></a> for inspiration). See the <a href="#Label">description of the Label concept</a> for the interface of a Label. See the <a href="#FunctionsDescription">algorithm description</a> for information on when these functions are called.
 <p>

 <a name="FunctionsDescription"><h3>Functions Description</h3></a>
@@ -133,7 +133,7 @@ out-edges for the whole graph.
 <PRE>
 vertex()
 </PRE>
-This operation is constant time for <TT>vecS</TT> and  for
+This operation is constant time for <TT>vecS</TT> and <i>O(V)</i> for
 <TT>listS</TT>.

 </ul>
@@ -3,12 +3,17 @@
 # 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)

-import ../../config/checks/config : requires ;
+require-b2 5.0.1 ;
+import-search /boost/config/checks ;
+
+import config : requires ;
 import modules ;
 import path ;

 path-constant TEST_DIR : . ;

+project : requirements <library>/boost/graph//boost_graph ;
+
 run accum-compile-times.cpp : $(TEST_DIR)/makefile-dependencies.dat $(TEST_DIR)/makefile-target-names.dat $(TEST_DIR)/target-compile-costs.dat ;
 exe actor_clustering : actor_clustering.cpp ;
 run adj_list_ra_edgelist.cpp ;
@@ -75,15 +80,15 @@ run filtered_graph.cpp ;
 run filtered_graph_edge_range.cpp ;
 run filtered_vec_as_graph.cpp ;
 run filtered-copy-example.cpp ;
-exe fr_layout : fr_layout.cpp : [ requires cxx11_noexcept cxx11_rvalue_references sfinae_expr cxx11_auto_declarations cxx11_lambdas cxx11_unified_initialization_syntax cxx11_hdr_tuple cxx11_hdr_initializer_list cxx11_hdr_chrono cxx11_thread_local cxx11_constexpr cxx11_nullptr cxx11_numeric_limits cxx11_decltype cxx11_hdr_array cxx11_hdr_atomic cxx11_hdr_type_traits cxx11_allocator cxx11_explicit_conversion_operators ] ;
+exe fr_layout : fr_layout.cpp /boost/timer//boost_timer : [ requires cxx11_noexcept cxx11_rvalue_references sfinae_expr cxx11_auto_declarations cxx11_lambdas cxx11_unified_initialization_syntax cxx11_hdr_tuple cxx11_hdr_initializer_list cxx11_hdr_chrono cxx11_thread_local cxx11_constexpr cxx11_nullptr cxx11_numeric_limits cxx11_decltype cxx11_hdr_array cxx11_hdr_atomic cxx11_hdr_type_traits cxx11_allocator cxx11_explicit_conversion_operators ] ;
 run gerdemann.cpp ;
 run graph.cpp ;
 run graph_as_tree.cpp ;
 run graph_property.cpp ;
 run graph-assoc-types.cpp ;
 run graph-property-iter-eg.cpp ;
-run graph-thingie.cpp ../build//boost_graph ;
-run graphviz.cpp ../build//boost_graph : $(TEST_DIR)/graphviz_example.dot ;
+run graph-thingie.cpp /boost/graph//boost_graph ;
+run graphviz.cpp /boost/graph//boost_graph : $(TEST_DIR)/graphviz_example.dot ;
 run grid_graph_example.cpp ;
 run grid_graph_properties.cpp ;
 exe hawick_circuits : hawick_circuits.cpp ;
@@ -114,7 +119,7 @@ exe mean_geodesic : mean_geodesic.cpp ;
 exe minimum_degree_ordering : minimum_degree_ordering.cpp ;
 run modify_graph.cpp ;
 run neighbor_bfs.cpp ;
-run ospf-example.cpp ../build//boost_graph : $(TEST_DIR)/figs/ospf-graph.dot $(TEST_DIR)/figs/ospf-sptree.dot $(TEST_DIR)/routing-table.dat ;
+run ospf-example.cpp /boost/graph//boost_graph : $(TEST_DIR)/figs/ospf-graph.dot $(TEST_DIR)/figs/ospf-sptree.dot $(TEST_DIR)/routing-table.dat ;
 run parallel-compile-time.cpp : $(TEST_DIR)/makefile-dependencies.dat $(TEST_DIR)/makefile-target-names.dat $(TEST_DIR)/target-compile-costs.dat ;
 run planar_face_traversal.cpp ;
 run prim-example.cpp ;
@@ -129,7 +134,7 @@ run put-get-helper-eg.cpp ;
 run quick_tour.cpp ;
 run quick-tour.cpp ;
 run r_c_shortest_paths_example.cpp ;
-run read_graphviz.cpp ../build//boost_graph ;
+run read_graphviz.cpp /boost/graph//boost_graph ;
 exe read_write_dimacs : read_write_dimacs-eg.cpp ;
 run remove_edge_if_bidir.cpp ;
 run remove_edge_if_dir.cpp ;
@@ -163,6 +168,7 @@ run vertex-name-property.cpp : $(TEST_DIR)/makefile-dependencies.dat $(TEST_DIR)
 run vf2_sub_graph_iso_example.cpp ;
 run vf2_sub_graph_iso_multi_example.cpp ;
 run visitor.cpp ;
+run weighted_matching_example.cpp ;
 run write_graphviz.cpp ;

 #
@@ -207,7 +213,7 @@ explicit girth ;
 #run edge-connectivity.cpp ;
 #
 # These compile, but still use the old graphviz interface and die and runtime:
-# run strong_components.cpp ../build//boost_graph ;
+# run strong_components.cpp /boost/graph//boost_graph ;


 #
@@ -72,12 +72,8 @@ int main(int argc, const char** argv)
    file_dep_graph2 g(input_begin, input_end, n_vertices);
 #endif

-    typedef property_map< file_dep_graph2, vertex_name_t >::type name_map_t;
-    typedef property_map< file_dep_graph2, vertex_compile_cost_t >::type
-        compile_cost_map_t;
-
-    name_map_t name_map = get(vertex_name, g);
-    compile_cost_map_t compile_cost_map = get(vertex_compile_cost, g);
+    auto name_map = get(vertex_name, g);
+    auto compile_cost_map = get(vertex_compile_cost, g);

    std::ifstream name_in(argc >= 3 ? argv[2] : "makefile-target-names.dat");
    std::ifstream compile_cost_in(
@@ -52,13 +52,13 @@ void load_actor_graph(std::istream& in, ActorGraph& g)
        // Map from the actor numbers on this line to the actor vertices
        typedef tokenizer< char_separator< char > > Tok;
        Tok tok(line, char_separator< char >(" "));
-        for (Tok::iterator id = tok.begin(); id != tok.end(); ++id)
+        for (auto const & id : tok)
        {
-            int actor_id = lexical_cast< int >(*id);
-            std::map< int, Vertex >::iterator v = actors.find(actor_id);
+            auto actor_id = lexical_cast< int >(id);
+            auto v = actors.find(actor_id);
            if (v == actors.end())
            {
-                Vertex new_vertex = add_vertex(Actor(actor_id), g);
+                auto new_vertex = add_vertex(Actor(actor_id), g);
                actors[actor_id] = new_vertex;
                actors_in_movie.push_back(new_vertex);
            }
@@ -68,11 +68,9 @@ void load_actor_graph(std::istream& in, ActorGraph& g)
            }
        }

-        for (std::vector< Vertex >::iterator i = actors_in_movie.begin();
-             i != actors_in_movie.end(); ++i)
+        for (auto i = actors_in_movie.begin(); i != actors_in_movie.end(); ++i)
        {
-            for (std::vector< Vertex >::iterator j = i + 1;
-                 j != actors_in_movie.end(); ++j)
+            for (auto j = i + 1; j != actors_in_movie.end(); ++j)
            {
                if (!edge(*i, *j, g).second)
                    add_edge(*i, *j, g);
@@ -86,16 +84,14 @@ std::ostream& write_pajek_graph(std::ostream& out, const Graph& g,
    VertexIndexMap vertex_index, VertexNameMap vertex_name)
 {
    out << "*Vertices " << num_vertices(g) << '\n';
-    typedef typename graph_traits< Graph >::vertex_iterator vertex_iterator;
-    for (vertex_iterator v = vertices(g).first; v != vertices(g).second; ++v)
+    for (auto v = vertices(g).first; v != vertices(g).second; ++v)
    {
        out << get(vertex_index, *v) + 1 << " \"" << get(vertex_name, *v)
            << "\"\n";
    }

    out << "*Edges\n";
-    typedef typename graph_traits< Graph >::edge_iterator edge_iterator;
-    for (edge_iterator e = edges(g).first; e != edges(g).second; ++e)
+    for (auto e = edges(g).first; e != edges(g).second; ++e)
    {
        out << get(vertex_index, source(*e, g)) + 1 << ' '
            << get(vertex_index, target(*e, g)) + 1 << " 1.0\n"; // HACK!
@@ -61,10 +61,8 @@ int main(int, char*[])
    const int V = 5;
    Graph g(V);

-    property_map< Graph, std::size_t VertexProperties::* >::type id
-        = get(&VertexProperties::index, g);
-    property_map< Graph, std::string EdgeProperties::* >::type name
-        = get(&EdgeProperties::name, g);
+    auto id = get(&VertexProperties::index, g);
+    auto name = get(&EdgeProperties::name, g);

    boost::graph_traits< Graph >::vertex_iterator vi, viend;
    int vnum = 0;
@@ -86,8 +86,8 @@ public:
    distance_heuristic(LocMap l, Vertex goal) : m_location(l), m_goal(goal) {}
    CostType operator()(Vertex u)
    {
-        CostType dx = m_location[m_goal].x - m_location[u].x;
-        CostType dy = m_location[m_goal].y - m_location[u].y;
+        auto dx = m_location[m_goal].x - m_location[u].x;
+        auto dy = m_location[m_goal].y - m_location[u].y;
        return ::sqrt(dx * dx + dy * dy);
    }

@@ -174,7 +174,7 @@ int main(int argc, char** argv)

    // create graph
    mygraph_t g(N);
-    WeightMap weightmap = get(edge_weight, g);
+    auto weightmap = get(edge_weight, g);
    for (std::size_t j = 0; j < num_edges; ++j)
    {
        edge_descriptor e;
@@ -185,9 +185,9 @@ int main(int argc, char** argv)
    }

    // pick random start/goal
-    boost::mt19937 gen(std::time(0));
-    vertex start = random_vertex(g, gen);
-    vertex goal = random_vertex(g, gen);
+    boost::mt19937 gen(time(0));
+    auto start = random_vertex(g, gen);
+    auto goal = random_vertex(g, gen);

    cout << "Start vertex: " << name[start] << endl;
    cout << "Goal vertex: " << name[goal] << endl;
@@ -215,7 +215,7 @@ int main(int argc, char** argv)
    catch (found_goal fg)
    { // found a path to the goal
        list< vertex > shortest_path;
-        for (vertex v = goal;; v = p[v])
+        for (auto v = goal;; v = p[v])
        {
            shortest_path.push_front(v);
            if (p[v] == v)
@@ -223,7 +223,7 @@ int main(int argc, char** argv)
        }
        cout << "Shortest path from " << name[start] << " to " << name[goal]
             << ": ";
-        list< vertex >::iterator spi = shortest_path.begin();
+        auto spi = shortest_path.begin();
        cout << name[start];
        for (++spi; spi != shortest_path.end(); ++spi)
            cout << " -> " << name[*spi];
@@ -201,8 +201,8 @@ bool maze::solve()
    dist_map distance;
    boost::associative_property_map< dist_map > dist_pmap(distance);

-    vertex_descriptor s = source();
-    vertex_descriptor g = goal();
+    auto s = source();
+    auto g = goal();
    euclidean_heuristic heuristic(g);
    astar_goal_visitor visitor(g);

@@ -218,7 +218,7 @@ bool maze::solve()
    {
        // Walk backwards from the goal through the predecessor chain adding
        // vertices to the solution path.
-        for (vertex_descriptor u = g; u != s; u = predecessor[u])
+        for (auto u = g; u != s; u = predecessor[u])
            m_solution.insert(u);
        m_solution.insert(s);
        m_solution_length = distance[g];
@@ -285,9 +285,9 @@ std::size_t random_int(std::size_t a, std::size_t b)
 // Generate a maze with a random assignment of barriers.
 void random_maze(maze& m)
 {
-    vertices_size_type n = num_vertices(m.m_grid);
-    vertex_descriptor s = m.source();
-    vertex_descriptor g = m.goal();
+    auto n = num_vertices(m.m_grid);
+    auto s = m.source();
+    auto g = m.goal();
    // One quarter of the cells in the maze should be barriers.
    int barriers = n / 4;
    while (barriers > 0)
@@ -297,7 +297,7 @@ void random_maze(maze& m)
        // Walls range up to one quarter the dimension length in this direction.
        vertices_size_type wall = random_int(1, m.length(direction) / 4);
        // Create the wall while decrementing the total barrier count.
-        vertex_descriptor u = vertex(random_int(0, n - 1), m.m_grid);
+        auto u = vertex(random_int(0, n - 1), m.m_grid);
        while (wall)
        {
            // Start and goal spaces should never be barriers.
@@ -310,7 +310,7 @@ void random_maze(maze& m)
                    barriers--;
                }
            }
-            vertex_descriptor v = m.m_grid.next(u, direction);
+            auto v = m.m_grid.next(u, direction);
            // Stop creating this wall if we reached the maze's edge.
            if (u == v)
                break;
@@ -23,8 +23,7 @@ template < typename Graph, typename ParentMap > struct edge_writer
    void operator()(std::ostream& out, const Edge& e) const
    {
        out << "[label=\"" << get(edge_weight, m_g, e) << "\"";
-        typename graph_traits< Graph >::vertex_descriptor u = source(e, m_g),
-                                                          v = target(e, m_g);
+        auto u = source(e, m_g), v = target(e, m_g);
        if (m_parent[v] == u)
            out << ", color=\"black\"";
        else
@@ -74,8 +73,7 @@ int main()
    Graph g(edge_array, edge_array + n_edges, N);
 #endif
    graph_traits< Graph >::edge_iterator ei, ei_end;
-    property_map< Graph, int EdgeProperties::* >::type weight_pmap
-        = get(&EdgeProperties::weight, g);
+    auto weight_pmap = get(&EdgeProperties::weight, g);
    int i = 0;
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei, ++i)
        weight_pmap[*ei] = weight[i];
@@ -115,9 +113,8 @@ int main()
    {
        for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
        {
-            graph_traits< Graph >::edge_descriptor e = *ei;
-            graph_traits< Graph >::vertex_descriptor u = source(e, g),
-                                                     v = target(e, g);
+            auto e = *ei;
+            auto u = source(e, g), v = target(e, g);
            // VC++ doesn't like the 3-argument get function, so here
            // we workaround by using 2-nested get()'s.
            dot_file << name[u] << " -> " << name[v] << "[label=\""
@@ -25,19 +25,18 @@ int main()
        H,
        n_vertices
    };
-    const int n_edges = 11;
    typedef std::pair< int, int > Edge;

    // The list of connections between routers stored in an array.
-    Edge edges[] = { Edge(A, B), Edge(A, C), Edge(B, D), Edge(B, E), Edge(C, E),
-        Edge(C, F), Edge(D, H), Edge(D, E), Edge(E, H), Edge(F, G),
+    Edge edges[] = { Edge(A, B), Edge(A, C), Edge(B, D), Edge(B, E),
+        Edge(C, E), Edge(C, F), Edge(D, H), Edge(D, E), Edge(E, H), Edge(F, G),
        Edge(G, H) };

    // Specify the graph type and declare a graph object
    typedef edge_list< Edge*, Edge, std::ptrdiff_t,
        std::random_access_iterator_tag >
        Graph;
-    Graph g(edges, edges + n_edges);
+    Graph g(std::begin(edges), std::end(edges));

    // The transmission delay values for each edge.
    float delay[] = { 5.0, 1.0, 1.3, 3.0, 10.0, 2.0, 6.3, 0.4, 1.3, 1.2, 0.5 };
@@ -81,7 +81,7 @@ int main()
    Size time = 0;
    typedef property_map< graph_t, std::size_t VertexProps::* >::type
        dtime_map_t;
-    dtime_map_t dtime_map = get(&VertexProps::discover_time, g);
+    auto dtime_map = get(&VertexProps::discover_time, g);
    bfs_time_visitor< dtime_map_t > vis(dtime_map, time);
    breadth_first_search(
        g, vertex(s, g), color_map(get(&VertexProps::color, g)).visitor(vis));
@@ -16,16 +16,15 @@ template < typename Graph, typename VertexNameMap, typename TransDelayMap >
 void build_router_network(
    Graph& g, VertexNameMap name_map, TransDelayMap delay_map)
 {
-    typename graph_traits< Graph >::vertex_descriptor a, b, c, d, e;
-    a = add_vertex(g);
+    auto a = add_vertex(g);
    name_map[a] = 'a';
-    b = add_vertex(g);
+    auto b = add_vertex(g);
    name_map[b] = 'b';
-    c = add_vertex(g);
+    auto c = add_vertex(g);
    name_map[c] = 'c';
-    d = add_vertex(g);
+    auto d = add_vertex(g);
    name_map[d] = 'd';
-    e = add_vertex(g);
+    auto e = add_vertex(g);
    name_map[e] = 'e';

    typename graph_traits< Graph >::edge_descriptor ed;
@@ -78,13 +77,13 @@ int main()
    typedef adjacency_list< listS, vecS, directedS, VP, EP > graph_t;
    graph_t g;

-    property_map< graph_t, char VP::* >::type name_map = get(&VP::name, g);
-    property_map< graph_t, double EP::* >::type delay_map = get(&EP::weight, g);
+    auto name_map = get(&VP::name, g);
+    auto delay_map = get(&EP::weight, g);

    build_router_network(g, name_map, delay_map);

    typedef property_map< graph_t, char VP::* >::type VertexNameMap;
-    graph_traits< graph_t >::vertex_descriptor a = *vertices(g).first;
+    auto a = *vertices(g).first;
    bfs_name_printer< VertexNameMap > vis(name_map);
    std::cout << "BFS vertex discover order: ";
    breadth_first_search(g, a, visitor(vis));
@@ -129,7 +129,7 @@ int main(int, char*[])
    std::fill_n(d, 5, 0);

    // The source vertex
-    Vertex s = *(boost::vertices(G).first);
+    auto s = *(boost::vertices(G).first);
    p[s] = s;
    boost::breadth_first_search(G, s,
        boost::visitor(boost::make_bfs_visitor(
@@ -123,7 +123,7 @@ int main(int, char*[])
    std::fill_n(d, 5, 0);

    // The source vertex
-    Vertex s = *(boost::vertices(G).first);
+    auto s = *(boost::vertices(G).first);
    p[s] = s;
    boost::neighbor_breadth_first_search(G, s,
        boost::visitor(boost::make_neighbor_bfs_visitor(
@@ -45,10 +45,9 @@ int main()
    add_edge(6, 7, g);
    add_edge(7, 8, g);

-    property_map< graph_t, edge_component_t >::type component
-        = get(edge_component, g);
+    auto component = get(edge_component, g);

-    std::size_t num_comps = biconnected_components(g, component);
+    auto num_comps = biconnected_components(g, component);
    std::cerr << "Found " << num_comps << " biconnected components.\n";

    std::vector< vertex_t > art_points;
@@ -29,9 +29,8 @@ public:
    void tree_edge(
        typename boost::graph_traits< Graph >::edge_descriptor e, Graph& g)
    {
-        typename boost::graph_traits< Graph >::vertex_descriptor u, v;
-        u = boost::source(e, g);
-        v = boost::target(e, g);
+        auto u = boost::source(e, g);
+        auto v = boost::target(e, g);
        distance[v] = distance[u] + 1;
    }

@@ -95,9 +94,8 @@ int main(int argc, const char** argv)
    NameVertexMap name2vertex;
    Graph g;

-    typedef property_map< Graph, vertex_name_t >::type NameMap;
-    NameMap node_name = get(vertex_name, g);
-    property_map< Graph, edge_name_t >::type link_name = get(edge_name, g);
+    auto node_name = get(vertex_name, g);
+    auto link_name = get(edge_name, g);

    //===========================================================================
    // Read the data file and construct the graph.
@@ -113,7 +111,7 @@ int main(int argc, const char** argv)
        bool inserted;
        Vertex u, v;

-        std::list< std::string >::iterator i = line_toks.begin();
+        auto i = line_toks.begin();

        boost::tie(pos, inserted)
            = name2vertex.insert(std::make_pair(*i, Vertex()));
@@ -210,6 +208,8 @@ int main(int argc, const char** argv)
    // the tree nodes in the order that we want to print out:
    // a directory-structure like format.
    std::vector< size_type > dfs_distances(num_vertices(g), 0);
+
+    using NameMap = property_map< Graph, vertex_name_t >::type;
    print_tree_visitor< NameMap, size_type* > tree_printer(
        node_name, &dfs_distances[0]);
    for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
@@ -85,17 +85,15 @@ int main()
        Graph;

    Graph g;
-    property_map< Graph, edge_capacity_t >::type capacity
-        = get(edge_capacity, g);
-    property_map< Graph, edge_residual_capacity_t >::type residual_capacity
-        = get(edge_residual_capacity, g);
-    property_map< Graph, edge_reverse_t >::type rev = get(edge_reverse, g);
+    auto capacity = get(edge_capacity, g);
+    auto residual_capacity = get(edge_residual_capacity, g);
+    auto rev = get(edge_reverse, g);
    Traits::vertex_descriptor s, t;
    read_dimacs_max_flow(g, capacity, rev, s, t);

    std::vector< default_color_type > color(num_vertices(g));
    std::vector< long > distance(num_vertices(g));
-    long flow = boykov_kolmogorov_max_flow(g, s, t);
+    auto flow = boykov_kolmogorov_max_flow(g, s, t);

    std::cout << "c  The total flow:" << std::endl;
    std::cout << "s " << flow << std::endl << std::endl;
@@ -29,7 +29,7 @@ int main(int argc, char* argv[])
    read_graph(g, cin);

    // Use the Bron-Kerbosch algorithm to find all cliques, and
-    size_t c = bron_kerbosch_clique_number(g);
+    auto c = bron_kerbosch_clique_number(g);
    cout << "clique number: " << c << endl;

    return 0;
@@ -47,7 +47,7 @@ int main()
            cout << " has number ";
            do
            {
-                int v = my_bucket_sorter[j].top();
+                auto v = my_bucket_sorter[j].top();
                my_bucket_sorter[j].pop();
                cout << v << " ";
            } while (!my_bucket_sorter[j].empty());
@@ -75,7 +75,7 @@ int main()
            cout << " has number ";
            do
            {
-                int v = my_bucket_sorter[j].top();
+                auto v = my_bucket_sorter[j].top();
                my_bucket_sorter[j].pop();
                cout << v << " ";
            } while (!my_bucket_sorter[j].empty());
@@ -93,7 +93,7 @@ int main()
        std::size_t current = rand() % N;
        if (!my_bucket_sorter[current].empty())
        {
-            int v = my_bucket_sorter[current].top();
+            auto v = my_bucket_sorter[current].top();
            my_bucket_sorter[current].pop();
            bucket[v] = rand() % N;
            my_bucket_sorter.push(v);
@@ -105,7 +105,7 @@ int main()
        std::size_t current = rand() % N;
        if (!my_bucket_sorter[current].empty())
        {
-            int v = my_bucket_sorter[current].top();
+            auto v = my_bucket_sorter[current].top();
            bucket[v] = rand() % N;
            my_bucket_sorter.update(v);
        }
@@ -44,7 +44,7 @@ int main(int argc, char** argv)
    add_edge(1, 5, g);

    // Initialize the interior edge index
-    property_map< graph, edge_index_t >::type e_index = get(edge_index, g);
+    auto e_index = get(edge_index, g);
    graph_traits< graph >::edges_size_type edge_count = 0;
    graph_traits< graph >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
@@ -69,10 +69,9 @@ int main(int argc, char** argv)
        make_iterator_property_map(embedding.begin(), get(vertex_index, g)),
        std::back_inserter(ordering));

-    ordering_storage_t::iterator oi, oi_end;
-    oi_end = ordering.end();
+    auto oi_end = ordering.end();
    std::cout << "The planar canonical ordering is: ";
-    for (oi = ordering.begin(); oi != oi_end; ++oi)
+    for (auto oi = ordering.begin(); oi != oi_end; ++oi)
        std::cout << *oi << " ";
    std::cout << std::endl;

@@ -32,8 +32,7 @@ int main()
        make_iterator_property_map(
            component.begin(), get(vertex_index, g), component[0]));

-    property_map< GraphvizGraph, vertex_attribute_t >::type vertex_attr_map
-        = get(vertex_attribute, g);
+    auto vertex_attr_map = get(vertex_attribute, g);
    std::string color[] = { "white", "gray", "black", "lightgray" };
    graph_traits< GraphvizGraph >::vertex_iterator vi, vi_end;
    for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
@@ -137,7 +137,7 @@ int main(int, char*[])
    cout << endl;

    /* Get the source vertex */
-    boost::graph_traits< Graph >::vertex_descriptor s = vertex(SanJose, G);
+    auto s = vertex(SanJose, G);

    cout << "*** Breadth First ***" << endl;
    breadth_first_search(G, s,
@@ -52,7 +52,7 @@ int main(int argc, char* argv[])
    // computation.
    ClusteringContainer coefs(num_vertices(g));
    ClusteringMap cm(coefs, g);
-    float cc = all_clustering_coefficients(g, cm);
+    auto cc = all_clustering_coefficients(g, cm);

    // Print the clustering coefficient of each vertex.
    graph_traits< Graph >::vertex_iterator i, end;
@@ -24,7 +24,7 @@ int main()
    add_edge(2, 5, G);

    std::vector< int > c(num_vertices(G));
-    int num = connected_components(
+    auto num = connected_components(
        G, make_iterator_property_map(c.begin(), get(vertex_index, G), c[0]));

    std::cout << std::endl;
@@ -49,7 +49,7 @@ int main(int, char*[])
        add_edge(2, 5, G);

        std::vector< int > component(num_vertices(G));
-        int num = connected_components(G, &component[0]);
+        auto num = connected_components(G, &component[0]);

        std::vector< int >::size_type i;
        cout << "Total number of components: " << num << endl;
@@ -30,7 +30,7 @@ int main()
        N
    };
    graph_t G(N);
-    property_map< graph_t, vertex_name_t >::type name_map = get(vertex_name, G);
+    auto name_map = get(vertex_name, G);
    char name = 'a';
    graph_traits< graph_t >::vertex_iterator v, v_end;
    for (boost::tie(v, v_end) = vertices(G); v != v_end; ++v, ++name)
@@ -57,32 +57,30 @@ int main(int, char*[])
        Pair(6, 7) }; // g-h

    Graph G(10);
-    for (int i = 0; i < 14; ++i)
-        add_edge(edges[i].first, edges[i].second, G);
+    for (auto const& edge : edges)
+        add_edge(edge.first, edge.second, G);

    graph_traits< Graph >::vertex_iterator ui, ui_end;

-    property_map< Graph, vertex_degree_t >::type deg = get(vertex_degree, G);
+    auto deg = get(vertex_degree, G);
    for (boost::tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
        deg[*ui] = degree(*ui, G);

-    property_map< Graph, vertex_index_t >::type index_map
-        = get(vertex_index, G);
+    auto index_map = get(vertex_index, G);

    std::cout << "original bandwidth: " << bandwidth(G) << std::endl;

    std::vector< Vertex > inv_perm(num_vertices(G));
    std::vector< size_type > perm(num_vertices(G));
    {
-        Vertex s = vertex(6, G);
+        auto s = vertex(6, G);
        // reverse cuthill_mckee_ordering
        cuthill_mckee_ordering(G, s, inv_perm.rbegin(), get(vertex_color, G),
            get(vertex_degree, G));
        cout << "Reverse Cuthill-McKee ordering starting at: " << s << endl;
        cout << "  ";
-        for (std::vector< Vertex >::const_iterator i = inv_perm.begin();
-             i != inv_perm.end(); ++i)
-            cout << index_map[*i] << " ";
+        for (auto const& vertex : inv_perm)
+            cout << index_map[vertex] << " ";
        cout << endl;

        for (size_type c = 0; c != inv_perm.size(); ++c)
@@ -94,15 +92,14 @@ int main(int, char*[])
                  << std::endl;
    }
    {
-        Vertex s = vertex(0, G);
+        auto s = vertex(0, G);
        // reverse cuthill_mckee_ordering
        cuthill_mckee_ordering(G, s, inv_perm.rbegin(), get(vertex_color, G),
            get(vertex_degree, G));
        cout << "Reverse Cuthill-McKee ordering starting at: " << s << endl;
        cout << "  ";
-        for (std::vector< Vertex >::const_iterator i = inv_perm.begin();
-             i != inv_perm.end(); ++i)
-            cout << index_map[*i] << " ";
+        for (auto const& vertex : inv_perm)
+            cout << index_map[vertex] << " ";
        cout << endl;

        for (size_type c = 0; c != inv_perm.size(); ++c)
@@ -121,9 +118,8 @@ int main(int, char*[])

        cout << "Reverse Cuthill-McKee ordering:" << endl;
        cout << "  ";
-        for (std::vector< Vertex >::const_iterator i = inv_perm.begin();
-             i != inv_perm.end(); ++i)
-            cout << index_map[*i] << " ";
+        for (auto const& vertex : inv_perm)
+            cout << index_map[vertex] << " ";
        cout << endl;

        for (size_type c = 0; c != inv_perm.size(); ++c)
@@ -21,7 +21,7 @@ int main()
    boost::edmonds_karp_max_flow(g, s, t);
    boost::cycle_canceling(g);

-    int cost = boost::find_flow_cost(g);
+    auto cost = boost::find_flow_cost(g);
    assert(cost == 29);
    return 0;
 }
@@ -50,12 +50,9 @@ int main(int argc, char* argv[])
    ccReal_t cc; /// critical cycle

    grap_real_t tgr;
-    property_map< grap_real_t, vertex_index_t >::type vim
-        = get(vertex_index, tgr);
-    property_map< grap_real_t, edge_weight_t >::type ew1
-        = get(edge_weight, tgr);
-    property_map< grap_real_t, edge_weight2_t >::type ew2
-        = get(edge_weight2, tgr);
+    auto vim = get(vertex_index, tgr);
+    auto ew1 = get(edge_weight, tgr);
+    auto ew2 = get(edge_weight2, tgr);

    gen_rand_graph(tgr, 1000, 30000);
    cout << "Vertices number: " << num_vertices(tgr) << endl;
@@ -72,12 +69,12 @@ int main(int argc, char* argv[])
    cout << "Minimum cycle ratio is " << min_cr << endl;
    std::pair< double, double > cr(.0, .0);
    cout << "Critical cycle:\n";
-    for (ccReal_t::iterator itr = cc.begin(); itr != cc.end(); ++itr)
+    for (auto const & edge : cc)
    {
-        cr.first += ew1[*itr];
-        cr.second += ew2[*itr];
-        std::cout << "(" << vim[source(*itr, tgr)] << ","
-                  << vim[target(*itr, tgr)] << ") ";
+        cr.first += ew1[edge];
+        cr.second += ew2[edge];
+        std::cout << "(" << vim[source(edge, tgr)] << ","
+                  << vim[target(edge, tgr)] << ") ";
    }
    cout << endl;
    assert(std::abs(cr.first / cr.second - min_cr) < epsilon * 2);
@@ -50,8 +50,7 @@ int main()
    add_edge(u, x, 1, g);
    add_edge(v, x, -2, g);

-    property_map< graph_t, vertex_distance_t >::type d_map
-        = get(vertex_distance, g);
+    auto d_map = get(vertex_distance, g);

 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
    // VC++ has trouble with the named-parameter mechanism, so
@@ -61,7 +60,7 @@ int main()
    default_dijkstra_visitor vis;
    std::less< int > compare;
    closed_plus< int > combine;
-    property_map< graph_t, edge_weight_t >::type w_map = get(edge_weight, g);
+    auto w_map = get(edge_weight, g);
    dag_shortest_paths(g, s, d_map, w_map, &color[0], &pred[0], vis, compare,
        combine, (std::numeric_limits< int >::max)(), 0);
 #else
@@ -169,8 +169,7 @@ int main(int, char*[])
    };

    Graph G(N);
-    boost::property_map< Graph, vertex_index_t >::type vertex_id
-        = get(vertex_index, G);
+    auto vertex_id = get(vertex_index, G);

    std::vector< weight_t > distance(N, (numeric_limits< weight_t >::max)());
    typedef boost::graph_traits< Graph >::vertex_descriptor Vertex;
@@ -44,13 +44,11 @@ int main(int, char*[])
    graph_traits< graph_t >::vertex_iterator i, iend;

    graph_t g(edge_array, edge_array + num_arcs, weights, num_nodes);
-    property_map< graph_t, edge_weight_t >::type weightmap
-        = get(edge_weight, g);
+    auto weightmap = get(edge_weight, g);

    // Manually intialize the vertex index and name maps
-    property_map< graph_t, vertex_index_t >::type indexmap
-        = get(vertex_index, g);
-    property_map< graph_t, vertex_name_t >::type name = get(vertex_name, g);
+    auto indexmap = get(vertex_index, g);
+    auto name = get(vertex_name, g);
    int c = 0;
    for (boost::tie(i, iend) = vertices(g); i != iend; ++i, ++c)
    {
@@ -58,12 +56,10 @@ int main(int, char*[])
        name[*i] = 'A' + c;
    }

-    vertex_descriptor s = vertex(A, g);
+    auto s = vertex(A, g);

-    property_map< graph_t, vertex_distance_t >::type d
-        = get(vertex_distance, g);
-    property_map< graph_t, vertex_predecessor_t >::type p
-        = get(vertex_predecessor, g);
+    auto d = get(vertex_distance, g);
+    auto p = get(vertex_predecessor, g);
    dijkstra_shortest_paths(g, s, predecessor_map(p).distance_map(d));

    std::cout << "distances and parents:" << std::endl;
@@ -87,9 +83,8 @@ int main(int, char*[])
    graph_traits< graph_t >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
    {
-        graph_traits< graph_t >::edge_descriptor e = *ei;
-        graph_traits< graph_t >::vertex_descriptor u = source(e, g),
-                                                   v = target(e, g);
+        auto e = *ei;
+        auto u = source(e, g), v = target(e, g);
        dot_file << name[u] << " -> " << name[v] << "[label=\""
                 << get(weightmap, e) << "\"";
        if (p[v] == u)
@@ -39,11 +39,10 @@ int main(int, char*[])
    int weights[] = { 1, 2, 1, 2, 7, 3, 1, 1, 1 };
    int num_arcs = sizeof(edge_array) / sizeof(Edge);
    graph_t g(edge_array, edge_array + num_arcs, weights, num_nodes);
-    property_map< graph_t, edge_weight_t >::type weightmap
-        = get(edge_weight, g);
+    auto weightmap = get(edge_weight, g);
    std::vector< vertex_descriptor > p(num_vertices(g));
    std::vector< int > d(num_vertices(g));
-    vertex_descriptor s = vertex(A, g);
+    auto s = vertex(A, g);

    dijkstra_shortest_paths(g, s,
        predecessor_map(boost::make_iterator_property_map(
@@ -73,9 +72,8 @@ int main(int, char*[])
    graph_traits< graph_t >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
    {
-        graph_traits< graph_t >::edge_descriptor e = *ei;
-        graph_traits< graph_t >::vertex_descriptor u = source(e, g),
-                                                   v = target(e, g);
+        auto e = *ei;
+        auto u = source(e, g), v = target(e, g);
        dot_file << name[u] << " -> " << name[v] << "[label=\""
                 << get(weightmap, e) << "\"";
        if (p[v] == u)
@@ -43,11 +43,10 @@ int main(int, char*[])
    int weights[] = { 1, 2, 1, 2, 7, 3, 1, 1, 1 };
    int num_arcs = sizeof(edge_array) / sizeof(Edge);
    graph_t g(edge_array, edge_array + num_arcs, weights, num_nodes);
-    property_map< graph_t, edge_weight_t >::type weightmap
-        = get(edge_weight, g);
+    auto weightmap = get(edge_weight, g);
    std::vector< vertex_descriptor > p(num_vertices(g));
    std::vector< int > d(num_vertices(g));
-    vertex_descriptor s = vertex(A, g);
+    auto s = vertex(A, g);

    dijkstra_shortest_paths_no_color_map(g, s,
        predecessor_map(boost::make_iterator_property_map(
@@ -78,8 +77,7 @@ int main(int, char*[])
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
    {
        graph_traits< graph_t >::edge_descriptor e = *ei;
-        graph_traits< graph_t >::vertex_descriptor u = source(e, g),
-                                                   v = target(e, g);
+        auto u = source(e, g), v = target(e, g);
        dot_file << name[u] << " -> " << name[v] << "[label=\""
                 << get(weightmap, e) << "\"";
        if (p[v] == u)
@@ -18,8 +18,8 @@ int main(int, char*[])

    typedef boost::directed_graph<> Graph;
    Graph g;
-    boost::graph_traits< Graph >::vertex_descriptor v0 = g.add_vertex();
-    boost::graph_traits< Graph >::vertex_descriptor v1 = g.add_vertex();
+    auto v0 = g.add_vertex();
+    auto v1 = g.add_vertex();

    g.add_edge(v0, v1);

@@ -30,7 +30,7 @@ min_degree_vertex(Graph& g)
 {
    typename graph_traits< Graph >::vertex_descriptor p;
    typedef typename graph_traits< Graph >::degree_size_type size_type;
-    size_type delta = (std::numeric_limits< size_type >::max)();
+    auto delta = (std::numeric_limits< size_type >::max)();
    typename graph_traits< Graph >::vertex_iterator i, iend;
    for (boost::tie(i, iend) = vertices(g); i != iend; ++i)
        if (degree(*i, g) < delta)
@@ -86,12 +86,9 @@ typename graph_traits< VertexListGraph >::degree_size_type edge_connectivity(
    std::vector< edge_descriptor > pred(num_vertices(g));

    FlowGraph flow_g(num_vertices(g));
-    typename property_map< FlowGraph, edge_capacity_t >::type cap
-        = get(edge_capacity, flow_g);
-    typename property_map< FlowGraph, edge_residual_capacity_t >::type res_cap
-        = get(edge_residual_capacity, flow_g);
-    typename property_map< FlowGraph, edge_reverse_t >::type rev_edge
-        = get(edge_reverse, flow_g);
+    auto cap = get(edge_capacity, flow_g);
+    auto res_cap = get(edge_residual_capacity, flow_g);
+    auto rev_edge = get(edge_reverse, flow_g);

    typename graph_traits< VertexListGraph >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
@@ -139,14 +136,13 @@ typename graph_traits< VertexListGraph >::degree_size_type edge_connectivity(
    }

    std::vector< bool > in_S_star(num_vertices(g), false);
-    typename std::vector< vertex_descriptor >::iterator si;
-    for (si = S_star.begin(); si != S_star.end(); ++si)
-        in_S_star[*si] = true;
+    for (auto const& vertex : S_star.begin())
+        in_S_star[vertex] = true;
    degree_size_type c = 0;
-    for (si = S_star.begin(); si != S_star.end(); ++si)
+    for (auto const& vertex : S_star.begin())
    {
        typename graph_traits< VertexListGraph >::out_edge_iterator ei, ei_end;
-        for (boost::tie(ei, ei_end) = out_edges(*si, g); ei != ei_end; ++ei)
+        for (boost::tie(ei, ei_end) = out_edges(vertex, g); ei != ei_end; ++ei)
            if (!in_S_star[target(*ei, g)])
            {
                *disconnecting_set++ = *ei;
@@ -166,21 +162,17 @@ int main()
    read_graphviz("figs/edge-connectivity.dot", g);

    typedef graph_traits< GraphvizGraph >::edge_descriptor edge_descriptor;
-    typedef graph_traits< GraphvizGraph >::degree_size_type degree_size_type;
    std::vector< edge_descriptor > disconnecting_set;
-    degree_size_type c
-        = edge_connectivity(g, std::back_inserter(disconnecting_set));
+    auto c = edge_connectivity(g, std::back_inserter(disconnecting_set));

    std::cout << "The edge connectivity is " << c << "." << std::endl;

-    property_map< GraphvizGraph, vertex_attribute_t >::type attr_map
-        = get(vertex_attribute, g);
+    auto attr_map = get(vertex_attribute, g);

    std::cout << "The disconnecting set is {";
-    for (std::vector< edge_descriptor >::iterator i = disconnecting_set.begin();
-         i != disconnecting_set.end(); ++i)
-        std::cout << "(" << attr_map[source(*i, g)]["label"] << ","
-                  << attr_map[target(*i, g)]["label"] << ") ";
+    for (auto const& edge : disconnecting_set)
+        std::cout << "(" << attr_map[source(edge, g)]["label"] << ","
+                  << attr_map[target(edge, g)]["label"] << ") ";
    std::cout << "}." << std::endl;
    return EXIT_SUCCESS;
 }
@@ -111,12 +111,12 @@ int main(int argc, const char** argv)

    graph_traits< graph_type >::vertex_descriptor yow, zag, bar;
    // Get vertex name property map from the graph
-    typedef property_map< graph_type, vertex_name_t >::type name_map_t;
-    name_map_t name = get(vertex_name, g);
+    auto name = get(vertex_name, g);
    // Get iterators for the vertex set
    graph_traits< graph_type >::vertex_iterator i, end;
    boost::tie(i, end) = vertices(g);
    // Find yow.h
+    using name_map_t = property_map< graph_type, vertex_name_t >::type;
    name_equals_t< name_map_t > predicate1("yow.h", name);
    yow = *std::find_if(i, end, predicate1);
    // Find zag.o
@@ -45,12 +45,12 @@ template < class Graph > struct exercise_edge
    void operator()(Edge e) const
    {
        // begin
-        // Get the associated vertex type out of the edge using the
-        // edge_traits class
-        // Use the source() and target() functions to access the vertices
-        // that belong to Edge e
-        Vertex src = source(e, G);
-        Vertex targ = target(e, G);
+        //  Get the associated vertex type out of the edge using the
+        //  edge_traits class
+        //  Use the source() and target() functions to access the vertices
+        //  that belong to Edge e
+        auto src = source(e, G);
+        auto targ = target(e, G);

        // print out the vertex id's just because
        cout << "(" << src << "," << targ << ") ";
@@ -49,8 +49,7 @@ int main()
    typedef graph_traits< UndirectedGraph >::degree_size_type degree_size_type;
    std::vector< edge_descriptor > disconnecting_set;

-    degree_size_type c
-        = edge_connectivity(g, std::back_inserter(disconnecting_set));
+    auto c = edge_connectivity(g, std::back_inserter(disconnecting_set));

    std::cout << "The edge connectivity is " << c << "." << std::endl;
    std::cout << "The disconnecting set is {";
@@ -60,7 +60,7 @@ public:
    }
    edge_stream_iterator operator++(int)
    {
-        edge_stream_iterator tmp = *this;
+        auto tmp = *this;
        m_read();
        return tmp;
    }
@@ -80,10 +80,8 @@ template < class Graph > void print_network(const Graph& G)
        typename boost::graph_traits< Graph >::out_edge_iterator OutEdgeIter;
    typedef typename boost::graph_traits< Graph >::in_edge_iterator InEdgeIter;

-    typename property_map< Graph, edge_mycapacity_t >::const_type capacity
-        = get(edge_mycapacity, G);
-    typename property_map< Graph, edge_myflow_t >::const_type flow
-        = get(edge_myflow, G);
+    auto capacity = get(edge_mycapacity, G);
+    auto flow = get(edge_myflow, G);

    Viter ui, uiend;
    boost::tie(ui, uiend) = vertices(G);
@@ -61,11 +61,9 @@ int main()

    Graph g;

-    property_map< Graph, edge_capacity_t >::type capacity
-        = get(edge_capacity, g);
-    property_map< Graph, edge_reverse_t >::type rev = get(edge_reverse, g);
-    property_map< Graph, edge_residual_capacity_t >::type residual_capacity
-        = get(edge_residual_capacity, g);
+    auto capacity = get(edge_capacity, g);
+    auto rev = get(edge_reverse, g);
+    auto residual_capacity = get(edge_residual_capacity, g);

    Traits::vertex_descriptor s, t;
    read_dimacs_max_flow(g, capacity, rev, s, t);
@@ -38,8 +38,7 @@ int main()

    graph_traits< adjacency_list<> >::vertex_iterator i, end;
    graph_traits< adjacency_list<> >::adjacency_iterator ai, a_end;
-    property_map< adjacency_list<>, vertex_index_t >::type index_map
-        = get(vertex_index, g);
+    auto index_map = get(vertex_index, g);

    for (boost::tie(i, end) = vertices(g); i != end; ++i)
    {
@@ -34,7 +34,7 @@ int main()
        uniform_int<> distrib(0, N - 1);
        boost::variate_generator< random_ns::mt19937&, uniform_int<> > rand_gen(
            gen, distrib);
-        for (int t = 0; t < 10; ++t)
+        for (std::size_t t = 0; t < 10; ++t)
        {
            std::vector< float > v, w(N);

@@ -45,7 +45,7 @@ int main()
        N
    };
    graph_t G(N);
-    property_map< graph_t, vertex_name_t >::type name_map = get(vertex_name, G);
+    auto name_map = get(vertex_name, G);
    char name = 'a';
    graph_traits< graph_t >::vertex_iterator v, v_end;
    for (boost::tie(v, v_end) = vertices(G); v != v_end; ++v, ++name)
@@ -65,7 +65,7 @@ int main()
    add_edge(D, B, 3, g);
    add_edge(E, C, 0, g);

-    EdgeWeightMap weight = get(edge_weight, g);
+    auto weight = get(edge_weight, g);

    std::cout << "unfiltered edge_range(C,D)\n";
    graph_traits< Graph >::out_edge_iterator f, l;
@@ -45,18 +45,15 @@ int main()
        B,
        C,
        D,
-        E,
-        N
+        E
    };
    const char* name = "ABCDE";
    typedef std::vector< std::list< int > > Graph;
-    Graph g(N);
-    g[A].push_back(B);
-    g[A].push_back(C);
-    g[C].push_back(D);
-    g[C].push_back(E);
-    g[D].push_back(E);
-    g[E].push_back(C);
+    Graph g = { { B, C }, // A
+        {}, // B
+        { D, E }, // C
+        { E }, // D
+        { C } }; // E

    constant_target filter(E);
    filtered_graph< Graph, constant_target > fg(g, filter);
@@ -49,14 +49,14 @@ void merge_vertex(typename boost::graph_traits< Graph >::vertex_descriptor u,
         ++out_i)
    {
        e = *out_i;
-        typename Traits::vertex_descriptor targ = target(e, g);
+        auto targ = target(e, g);
        add_edge(u, targ, getp(e), g);
    }
    typename Traits::in_edge_iterator in_i, in_end;
    for (boost::tie(in_i, in_end) = in_edges(v, g); in_i != in_end; ++in_i)
    {
        e = *in_i;
-        typename Traits::vertex_descriptor src = source(e, g);
+        auto src = source(e, g);
        add_edge(src, u, getp(e), g);
    }
    clear_vertex(v, g);
@@ -131,8 +131,8 @@ int main()
    add_edge(3, 4, EdgeProperty('h'), g);
    add_edge(0, 1, EdgeProperty('c'), g);

-    property_map< graph_type, vertex_index_t >::type id = get(vertex_index, g);
-    property_map< graph_type, edge_name_t >::type name = get(edge_name, g);
+    auto id = get(vertex_index, g);
+    auto name = get(edge_name, g);

    graph_traits< graph_type >::vertex_iterator i, end;
    graph_traits< graph_type >::out_edge_iterator ei, edge_end;
@@ -75,7 +75,7 @@ public:

    void tree_edge(edge_descriptor e, Graph* g)
    {
-        vertex_descriptor u = source(e, g), v = target(e, g);
+        auto u = source(e, g), v = target(e, g);
        k = d_map[u] + 1;
        d_map[v] = k;
        ++distance_list[k];
@@ -83,7 +83,7 @@ public:
    }
    void non_tree_edge(edge_descriptor e, Graph* g)
    {
-        vertex_descriptor u = source(e, g), v = target(e, g);
+        auto u = source(e, g), v = target(e, g);
        k = d_map[u] + 1;
        if (d_map[v] + k < girth && v != p_map[u])
            girth = d_map[v] + k;
@@ -14,6 +14,7 @@
 #include <boost/foreach.hpp>
 #include <string>
 #include <sstream>
+#include <cstdlib>

 using namespace boost;
 using namespace std;
@@ -51,18 +52,16 @@ int main()
    graph_t graph(0);
    dynamic_properties dp;

-    property_map< graph_t, vertex_name_t >::type vname
-        = get(vertex_name, graph);
+    auto vname = get(vertex_name, graph);
    dp.property("node_id", vname);

-    property_map< graph_t, vertex_label_t >::type vlabel
-        = get(vertex_label_t(), graph);
+    auto vlabel = get(vertex_label_t(), graph);
    dp.property("label", vlabel);

-    property_map< graph_t, vertex_root_t >::type root = get(vertex_root, graph);
+    auto root = get(vertex_root, graph);
    dp.property("root", root);

-    property_map< graph_t, edge_name_t >::type elabel = get(edge_name, graph);
+    auto elabel = get(edge_name, graph);
    dp.property("label", elabel);

    // Use ref_property_map to turn a graph property into a property map
@@ -104,5 +103,5 @@ int main()
             << get("label", dp, v) << ")\n";
    }

-    return 0;
+    return status ? EXIT_SUCCESS : EXIT_FAILURE;
 }
@@ -39,13 +39,12 @@ int main()

    graph_t g;

-    vertex_t a = add_vertex(g), b = add_vertex(g), c = add_vertex(g);
+    auto a = add_vertex(g), b = add_vertex(g), c = add_vertex(g);

    add_edge(a, b, g);
    add_edge(a, c, g);

-    typedef property_map< graph_t, vertex_name_t >::type vertex_name_map_t;
-    vertex_name_map_t name = get(vertex_name, g);
+    auto name = get(vertex_name, g);
    name[a] = "A";
    name[b] = "B";
    name[c] = "C";
@@ -35,7 +35,7 @@ int main(int argc, char* argv[])
    put(dataMap, v, 2.0f);

    // Get the data at the node at position (0,1) in the grid
-    float retrieved = get(dataMap, v);
+    auto retrieved = get(dataMap, v);
    std::cout << "Retrieved value: " << retrieved << std::endl;

    return 0;
@@ -28,10 +28,7 @@ template < typename OutputStream > struct cycle_printer

        // Get the property map containing the vertex indices
        // so we can print them.
-        typedef typename boost::property_map< Graph,
-            boost::vertex_index_t >::const_type IndexMap;
-
-        IndexMap indices = get(boost::vertex_index, g);
+        auto indices = get(boost::vertex_index, g);

        // Iterate over path printing each vertex that forms the cycle.
        typename Path::const_iterator i, before_end = boost::prior(p.end());
@@ -223,7 +223,7 @@ private:
        static const int ring_offset[] = { 1, -1 };
        vertex_descriptor v;

-        std::size_t p = *this->base_reference();
+        auto p = *this->base_reference();
        if (m_u == 0 && p == 1)
            v = m_n - 1; // Vertex n-1 precedes vertex 0.
        else
@@ -63,7 +63,7 @@ int main(int argc, char* argv[])
    graph_traits< Graph >::vertex_iterator i, end;
    for (boost::tie(i, end) = vertices(g); i != end; ++i)
    {
-        Vertex v = *i;
+        auto v = *i;
        cout << setiosflags(ios::left) << setw(12) << g[v].name << "\t" << im[v]
             << "\t" << pm[v] << endl;
    }
@@ -61,7 +61,7 @@ void who_owes_who(EdgeIter first, EdgeIter last, const Graph& G)
    // Access the propety acessor type for this graph
    typedef
        typename property_map< Graph, vertex_first_name_t >::const_type NamePA;
-    NamePA name = get(vertex_first_name, G);
+    auto name = get(vertex_first_name, G);

    typedef typename boost::property_traits< NamePA >::value_type NameType;

@@ -778,13 +778,13 @@ int writeHB_mat_double(const char* filename, int M, int N,

    if ( Ptrfmt == NULL ) Ptrfmt = "(8I10)";
    ParseIfmt(Ptrfmt,&Ptrperline,&Ptrwidth);
-    sprintf(pformat,"%%%dd",Ptrwidth);
+    snprintf(pformat, sizeof(pformat), "%%%dd", Ptrwidth);
    ptrcrd = (N+1)/Ptrperline;
    if ( (N+1)%Ptrperline != 0) ptrcrd++;

    if ( Indfmt == NULL ) Indfmt =  Ptrfmt;
    ParseIfmt(Indfmt,&Indperline,&Indwidth);
-    sprintf(iformat,"%%%dd",Indwidth);
+    snprintf(iformat, sizeof(iformat), "%%%dd", Indwidth);
    indcrd = nz/Indperline;
    if ( nz%Indperline != 0) indcrd++;

@@ -793,9 +793,9 @@ int writeHB_mat_double(const char* filename, int M, int N,
      ParseRfmt(Valfmt,&Valperline,&Valwidth,&Valprec,&Valflag);
      if (Valflag == 'D') *strchr(Valfmt,'D') = 'E';
      if (Valflag == 'F')
-         sprintf(vformat,"%% %d.%df",Valwidth,Valprec);
+          snprintf(vformat, sizeof(vformat), "%% %d.%df", Valwidth, Valprec);
      else
-         sprintf(vformat,"%% %d.%dE",Valwidth,Valprec);
+         snprintf(vformat, sizeof(vformat), "%% %d.%dE", Valwidth, Valprec);
      valcrd = nvalentries/Valperline;
      if ( nvalentries%Valperline != 0) valcrd++;
    } else valcrd = 0;
@@ -804,9 +804,9 @@ int writeHB_mat_double(const char* filename, int M, int N,
       if ( Rhsfmt == NULL ) Rhsfmt = Valfmt;
       ParseRfmt(Rhsfmt,&Rhsperline,&Rhswidth,&Rhsprec, &Rhsflag);
       if (Rhsflag == 'F')
-          sprintf(rformat,"%% %d.%df",Rhswidth,Rhsprec);
+          snprintf(rformat, sizeof(rformat), "%% %d.%df", Rhswidth, Rhsprec);
       else
-          sprintf(rformat,"%% %d.%dE",Rhswidth,Rhsprec);
+          snprintf(rformat, sizeof(rformat), "%% %d.%dE", Rhswidth, Rhsprec);
       if (Rhsflag == 'D') *strchr(Rhsfmt,'D') = 'E';
       rhscrd = nrhsentries/Rhsperline;
       if ( nrhsentries%Rhsperline != 0) rhscrd++;
@@ -1361,16 +1361,16 @@ int writeHB_mat_char(const char* filename, int M, int N,

    if ( Ptrfmt == NULL ) Ptrfmt = "(8I10)";
    ParseIfmt(Ptrfmt,&Ptrperline,&Ptrwidth);
-    sprintf(pformat,"%%%dd",Ptrwidth);
+    snprintf(pformat, sizeof(pformat), "%%%dd", Ptrwidth);

    if ( Indfmt == NULL ) Indfmt =  Ptrfmt;
    ParseIfmt(Indfmt,&Indperline,&Indwidth);
-    sprintf(iformat,"%%%dd",Indwidth);
+    snprintf(iformat, sizeof(iformat), "%%%dd", Indwidth);

    if ( Type[0] != 'P' ) {          /* Skip if pattern only  */
      if ( Valfmt == NULL ) Valfmt = "(4E20.13)";
      ParseRfmt(Valfmt,&Valperline,&Valwidth,&Valprec,&Valflag);
-      sprintf(vformat,"%%%ds",Valwidth);
+      snprintf(vformat, sizeof(vformat), "%%%ds", Valwidth);
    }

    ptrcrd = (N+1)/Ptrperline;
@@ -1385,7 +1385,7 @@ int writeHB_mat_char(const char* filename, int M, int N,
    if ( Nrhs > 0 ) {
       if ( Rhsfmt == NULL ) Rhsfmt = Valfmt;
       ParseRfmt(Rhsfmt,&Rhsperline,&Rhswidth,&Rhsprec, &Rhsflag);
-       sprintf(rformat,"%%%ds",Rhswidth);
+       snprintf(rformat, sizeof(rformat), "%%%ds", Rhswidth);
       rhscrd = nrhsentries/Rhsperline;
       if ( nrhsentries%Rhsperline != 0) rhscrd++;
       if ( Rhstype[1] == 'G' ) rhscrd+=rhscrd;
@@ -45,8 +45,7 @@ int main()

    graph_traits< adjacency_list<> >::vertex_iterator i, end;
    graph_traits< adjacency_list<> >::adjacency_iterator ai, a_end;
-    property_map< adjacency_list<>, vertex_index_t >::type index_map
-        = get(vertex_index, g);
+    auto index_map = get(vertex_index, g);

    BGL_FORALL_VERTICES(i, g, adjacency_list<>)
    {
@@ -36,7 +36,7 @@ int main()
    Graph g(edge_array, edge_array + E, V);
 #endif

-    property_map< Graph, edge_weight_t >::type w = get(edge_weight, g);
+    auto w = get(edge_weight, g);
    int weights[] = { 0, 0, 0, 0, 0, 3, -4, 8, 1, 7, 4, -5, 2, 6 };
    int* wp = weights;

@@ -58,10 +58,8 @@ int main(int argc, const char** argv)
        Graph;
    Graph g;

-    typedef property_map< Graph, vertex_name_t >::type actor_name_map_t;
-    actor_name_map_t actor_name = get(vertex_name, g);
-    typedef property_map< Graph, edge_name_t >::type movie_name_map_t;
-    movie_name_map_t connecting_movie = get(edge_name, g);
+    auto actor_name = get(vertex_name, g);
+    auto connecting_movie = get(edge_name, g);

    typedef graph_traits< Graph >::vertex_descriptor Vertex;
    typedef std::map< std::string, Vertex > NameVertexMap;
@@ -65,7 +65,7 @@ public:

    void tree_edge(Edge e, const Graph& g) const
    {
-        Vertex u = source(e, g), v = target(e, g);
+        auto u = source(e, g), v = target(e, g);
        d[v] = d[u] + 1;
    }

@@ -62,26 +62,24 @@ int main(int, char*[])

    graph_traits< Graph >::vertex_iterator ui, ui_end;

-    property_map< Graph, vertex_degree_t >::type deg = get(vertex_degree, G);
+    auto deg = get(vertex_degree, G);
    for (boost::tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
        deg[*ui] = degree(*ui, G);

-    property_map< Graph, vertex_index_t >::type index_map
-        = get(vertex_index, G);
+    auto index_map = get(vertex_index, G);

    std::cout << "original bandwidth: " << bandwidth(G) << std::endl;

    std::vector< Vertex > inv_perm(num_vertices(G));
    std::vector< size_type > perm(num_vertices(G));
    {
-        Vertex s = vertex(6, G);
+        auto s = vertex(6, G);
        // king_ordering
        king_ordering(G, s, inv_perm.rbegin(), get(vertex_color, G),
            get(vertex_degree, G), get(vertex_index, G));
        cout << "King ordering starting at: " << s << endl;
        cout << "  ";
-        for (std::vector< Vertex >::const_iterator i = inv_perm.begin();
-             i != inv_perm.end(); ++i)
+        for (auto i = inv_perm.begin(); i != inv_perm.end(); ++i)
            cout << index_map[*i] << " ";
        cout << endl;

@@ -100,9 +98,8 @@ int main(int, char*[])
            get(vertex_degree, G), get(vertex_index, G));
        cout << "King ordering starting at: " << s << endl;
        cout << "  ";
-        for (std::vector< Vertex >::const_iterator i = inv_perm.begin();
-             i != inv_perm.end(); ++i)
-            cout << index_map[*i] << " ";
+        for (auto const& vertex : inv_perm)
+            cout << index_map[vertex] << " ";
        cout << endl;

        for (size_type c = 0; c != inv_perm.size(); ++c)
@@ -121,9 +118,8 @@ int main(int, char*[])

        cout << "King ordering:" << endl;
        cout << "  ";
-        for (std::vector< Vertex >::const_iterator i = inv_perm.begin();
-             i != inv_perm.end(); ++i)
-            cout << index_map[*i] << " ";
+        for (auto const& vertex : inv_perm)
+            cout << index_map[vertex] << " ";
        cout << endl;

        for (size_type c = 0; c != inv_perm.size(); ++c)
@@ -26,7 +26,7 @@ int main()
    std::size_t num_edges = sizeof(edge_array) / sizeof(E);
 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
    Graph g(num_nodes);
-    property_map< Graph, edge_weight_t >::type weightmap = get(edge_weight, g);
+    auto = get(edge_weight, g);
    for (std::size_t j = 0; j < num_edges; ++j)
    {
        Edge e;
@@ -38,14 +38,14 @@ int main()
 #else
    Graph g(edge_array, edge_array + num_edges, weights, num_nodes);
 #endif
-    property_map< Graph, edge_weight_t >::type weight = get(edge_weight, g);
+
+    auto weight = get(edge_weight, g);
    std::vector< Edge > spanning_tree;

    kruskal_minimum_spanning_tree(g, std::back_inserter(spanning_tree));

    std::cout << "Print the edges in the MST:" << std::endl;
-    for (std::vector< Edge >::iterator ei = spanning_tree.begin();
-         ei != spanning_tree.end(); ++ei)
+    for (auto ei = spanning_tree.begin(); ei != spanning_tree.end(); ++ei)
    {
        std::cout << source(*ei, g) << " <--> " << target(*ei, g)
                  << " with weight of " << weight[*ei] << std::endl;
@@ -30,8 +30,7 @@ int main()
        property< edge_weight_t, int > >
        Graph;
    Graph g(num_vertices(g_dot));
-    property_map< GraphvizGraph, edge_attribute_t >::type edge_attr_map
-        = get(edge_attribute, g_dot);
+    auto edge_attr_map = get(edge_attribute, g_dot);
    graph_traits< GraphvizGraph >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g_dot); ei != ei_end; ++ei)
    {
@@ -45,22 +44,20 @@ int main()
        size_type;
    kruskal_minimum_spanning_tree(g, std::back_inserter(mst));

-    property_map< Graph, edge_weight_t >::type weight = get(edge_weight, g);
+    auto weight = get(edge_weight, g);
    int total_weight = 0;
-    for (size_type e = 0; e < mst.size(); ++e)
-        total_weight += get(weight, mst[e]);
+    for (auto const& edge : mst)
+        total_weight += get(weight, edge);
    std::cout << "total weight: " << total_weight << std::endl;

    typedef graph_traits< Graph >::vertex_descriptor Vertex;
-    for (size_type i = 0; i < mst.size(); ++i)
+    for (auto const& edge : mst)
    {
-        Vertex u = source(mst[i], g), v = target(mst[i], g);
+        auto u = source(edge, g), v = target(edge, g);
        edge_attr_map[edge(u, v, g_dot).first]["color"] = "black";
    }
    std::ofstream out("figs/telephone-mst-kruskal.dot");
-    graph_property< GraphvizGraph, graph_edge_attribute_t >::type&
-        graph_edge_attr_map
-        = get_property(g_dot, graph_edge_attribute);
+    auto graph_edge_attr_map = get_property(g_dot, graph_edge_attribute);
    graph_edge_attr_map["color"] = "gray";
    graph_edge_attr_map["style"] = "bold";
    write_graphviz(out, g_dot);
@@ -45,7 +45,7 @@ int main(int argc, char** argv)
    add_edge(4, 5, g);

    // Initialize the interior edge index
-    property_map< graph, edge_index_t >::type e_index = get(edge_index, g);
+    auto e_index = get(edge_index, g);
    graph_traits< graph >::edges_size_type edge_count = 0;
    graph_traits< graph >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
@@ -76,8 +76,7 @@ int main(int argc, const char** argv)
        exit(-1);
    }
    // Obtain internal property map from the graph
-    property_map< graph_type, vertex_name_t >::type name_map
-        = get(vertex_name, g);
+    auto name_map = get(vertex_name, g);
    read_graph_file(file_in, name_in, g, name_map);

    // Create storage for last modified times
@@ -89,7 +88,7 @@ int main(int argc, const char** argv)
    // Create last modified time property map
    iter_map_t mod_time_map(last_mod_vec.begin(), get(vertex_index, g));

-    property_map< graph_type, vertex_name_t >::type name = get(vertex_name, g);
+    auto name = get(vertex_name, g);
    struct stat stat_buf;
    graph_traits< graph_type >::vertex_descriptor u;
    typedef graph_traits< graph_type >::vertex_iterator vertex_iter_t;
@@ -19,7 +19,7 @@ int main()
    g.new_node("Eurystheus");
    g.new_node("Amphitryon");
    typedef property_map< graph_t, vertex_all_t >::type NodeMap;
-    NodeMap node_name_map = get(vertex_all, g);
+    auto node_name_map = get(vertex_all, g);
    graph_traits< graph_t >::vertex_iterator vi, vi_end;
    for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
        std::cout << node_name_map[*vi] << std::endl;
@@ -133,20 +133,18 @@ int main(int argc, char* argv[])
    typedef std::set< Vertex > set_t;
    typedef std::list< set_t > list_of_sets_t;
    list_of_sets_t loops;
-    Vertex entry = *vertices(g).first;
+    auto entry = *vertices(g).first;

    find_loops(entry, g, loops);

-    property_map< Graph, vertex_attribute_t >::type vattr_map
-        = get(vertex_attribute, g);
-    property_map< Graph, edge_attribute_t >::type eattr_map
-        = get(edge_attribute, g);
+    auto vattr_map = get(vertex_attribute, g);
+    auto eattr_map = get(edge_attribute, g);
    graph_traits< Graph >::edge_iterator ei, ei_end;

-    for (list_of_sets_t::iterator i = loops.begin(); i != loops.end(); ++i)
+    for (auto i = loops.begin(); i != loops.end(); ++i)
    {
        std::vector< bool > in_loop(num_vertices(g), false);
-        for (set_t::iterator j = (*i).begin(); j != (*i).end(); ++j)
+        for (auto j = (*i).begin(); j != (*i).end(); ++j)
        {
            vattr_map[*j]["color"] = "gray";
            in_loop[*j] = true;
@@ -167,9 +165,7 @@ int main(int argc, char* argv[])
    for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
    {
        loops_out << *vi << "[";
-        for (std::map< std::string, std::string >::iterator ai
-             = vattr_map[*vi].begin();
-             ai != vattr_map[*vi].end(); ++ai)
+        for (auto ai = vattr_map[*vi].begin(); ai != vattr_map[*vi].end(); ++ai)
        {
            loops_out << ai->first << "=" << ai->second;
            if (next(ai) != vattr_map[*vi].end())
@@ -181,10 +177,8 @@ int main(int argc, char* argv[])
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
    {
        loops_out << source(*ei, g) << " -> " << target(*ei, g) << "[";
-        std::map< std::string, std::string >& attr_map = eattr_map[*ei];
-        for (std::map< std::string, std::string >::iterator eai
-             = attr_map.begin();
-             eai != attr_map.end(); ++eai)
+        auto& attr_map = eattr_map[*ei];
+        for (auto eai = attr_map.begin(); eai != attr_map.end(); ++eai)
        {
            loops_out << eai->first << "=" << eai->second;
            if (next(eai) != attr_map.end())
@@ -41,7 +41,7 @@ int main(int argc, char** argv)
    add_edge(0, 10, g);

    // Initialize the interior edge index
-    property_map< graph, edge_index_t >::type e_index = get(edge_index, g);
+    auto e_index = get(edge_index, g);
    graph_traits< graph >::edges_size_type edge_count = 0;
    graph_traits< graph >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
@@ -60,7 +60,7 @@ int main(int argc, char** argv)
              << 2 * num_vertices(g) - 4 << " faces." << std::endl;

    // Initialize the interior edge index
-    property_map< graph, edge_index_t >::type e_index = get(edge_index, g);
+    auto e_index = get(edge_index, g);
    graph_traits< graph >::edges_size_type edge_count = 0;
    graph_traits< graph >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
@@ -25,15 +25,14 @@ int main()

    const int n_vertices = 18;

-    std::vector< std::string > ascii_graph;
-
-    ascii_graph.push_back("           0       1---2       3       ");
-    ascii_graph.push_back("            \\     /     \\     /        ");
-    ascii_graph.push_back("             4---5       6---7         ");
-    ascii_graph.push_back("             |   |       |   |         ");
-    ascii_graph.push_back("             8---9      10---11        ");
-    ascii_graph.push_back("            /     \\     /     \\        ");
-    ascii_graph.push_back("     12   13      14---15      16   17 ");
+    std::vector< std::string > ascii_graph
+        = { "           0       1---2       3       ",
+              "            \\     /     \\     /        ",
+              "             4---5       6---7         ",
+              "             |   |       |   |         ",
+              "             8---9      10---11        ",
+              "            /     \\     /     \\        ",
+              "     12   13      14---15      16   17 " };

    // It has a perfect matching of size 8. There are two isolated
    // vertices that we'll use later...
@@ -75,9 +74,8 @@ int main()

    std::cout << "In the following graph:" << std::endl << std::endl;

-    for (std::vector< std::string >::iterator itr = ascii_graph.begin();
-         itr != ascii_graph.end(); ++itr)
-        std::cout << *itr << std::endl;
+    for (auto const& str : ascii_graph)
+        std::cout << str << std::endl;

    std::cout << std::endl
              << "Found a matching of size " << matching_size(g, &mate[0])
@@ -106,8 +104,7 @@ int main()

    std::cout << "In the following graph:" << std::endl << std::endl;

-    for (std::vector< std::string >::iterator itr = ascii_graph.begin();
-         itr != ascii_graph.end(); ++itr)
+    for (auto itr = ascii_graph.begin(); itr != ascii_graph.end(); ++itr)
        std::cout << *itr << std::endl;

    std::cout << std::endl
@@ -62,11 +62,9 @@ int main()

    Graph g;

-    property_map< Graph, edge_capacity_t >::type capacity
-        = get(edge_capacity, g);
-    property_map< Graph, edge_reverse_t >::type rev = get(edge_reverse, g);
-    property_map< Graph, edge_residual_capacity_t >::type residual_capacity
-        = get(edge_residual_capacity, g);
+    auto capacity = get(edge_capacity, g);
+    auto rev = get(edge_reverse, g);
+    auto residual_capacity = get(edge_residual_capacity, g);

    Traits::vertex_descriptor s, t;
    read_dimacs_max_flow(g, capacity, rev, s, t);
@@ -81,14 +81,12 @@ int main(int argc, char* argv[])
        property< edge_name_t, unsigned int > >
        Graph;

-    typedef property_map< Graph, vertex_name_t >::type VertexNameMap;
-
    // Test maximum and unique variants on known graphs
    Graph graph_simple1, graph_simple2;
    example_callback< Graph > user_callback(graph_simple1);

-    VertexNameMap vname_map_simple1 = get(vertex_name, graph_simple1);
-    VertexNameMap vname_map_simple2 = get(vertex_name, graph_simple2);
+    auto vname_map_simple1 = get(vertex_name, graph_simple1);
+    auto vname_map_simple2 = get(vertex_name, graph_simple2);

    // Graph that looks like a triangle
    put(vname_map_simple1, add_vertex(graph_simple1), 1);
@@ -71,7 +71,7 @@ int main(int argc, char* argv[])
    // so-called small-world distance) as a result.
    GeodesicContainer geodesics(num_vertices(g));
    GeodesicMap gm(geodesics, g);
-    float sw = all_mean_geodesics(g, dm, gm);
+    auto sw = all_mean_geodesics(g, dm, gm);

    // Print the mean geodesic distance of each vertex and finally,
    // the graph itself.
@@ -102,11 +102,9 @@ int main(int argc, char* argv[])
        long sp_length = 0;

        // Use the "z" utility field for distance.
-        typedef property_map< Graph*, z_property< long > >::type Distance;
-        Distance d = get(z_property< long >(), g);
+        auto d = get(z_property< long >(), g);
        // Use the "w" property for parent
-        typedef property_map< Graph*, w_property< Vertex* > >::type Parent;
-        Parent p = get(w_property< Vertex* >(), g);
+        auto p = get(w_property< Vertex* >(), g);
        total_length_visitor< Distance > length_vis(sp_length, d);

        prim_minimum_spanning_tree(g, p,
@@ -52,14 +52,14 @@ int main(int, char*[])
    const char name[] = "abcdef";

    const int num_nodes = 6;
-    E edges[] = { E(0, 2), E(1, 1), E(1, 3), E(1, 4), E(2, 1), E(2, 3), E(3, 4),
-        E(4, 0), E(4, 1) };
+    const auto edges = { E(0, 2), E(1, 1), E(1, 3), E(1, 4), E(2, 1), E(2, 3),
+        E(3, 4), E(4, 0), E(4, 1) };
    int weights[] = { 1, 2, 1, 2, 7, 3, 1, 1, 1 };
    const int n_edges = sizeof(edges) / sizeof(E);
 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
    // VC++ can't handle iterator constructors
    Graph G(num_nodes);
-    property_map< Graph, edge_weight_t >::type weightmap = get(edge_weight, G);
+    auto weightmap = get(edge_weight, G);
    for (std::size_t j = 0; j < sizeof(edges) / sizeof(E); ++j)
    {
        graph_traits< Graph >::edge_descriptor e;
@@ -68,8 +68,8 @@ int main(int, char*[])
        weightmap[e] = weights[j];
    }
 #else
-    Graph G(edges, edges + n_edges, weights, num_nodes);
-    property_map< Graph, edge_weight_t >::type weightmap = get(edge_weight, G);
+    Graph G(std::begin(edges), std::end(edges), weights, num_nodes);
+    auto = get(edge_weight, G);
 #endif

    std::vector< Vertex > p(num_vertices(G));
@@ -146,8 +146,7 @@ int main(int argc, char* argv[])

    Vector supernode_sizes(n, 1); // init has to be 1

-    boost::property_map< Graph, vertex_index_t >::type id
-        = get(vertex_index, G);
+    auto id = get(vertex_index, G);

    Vector degree(n, 0);

@@ -47,8 +47,7 @@ template < class MutableGraph > void modify_demo(MutableGraph& g)
    typename GraphTraits::edges_size_type m = 0;
    typename GraphTraits::vertex_descriptor u, v, w;
    edge_descriptor e, e1, e2;
-    typename property_map< MutableGraph, edge_name_t >::type name_map
-        = get(edge_name, g);
+    auto name_map = get(edge_name, g);
    bool added;
    typename GraphTraits::vertex_iterator vi, vi_end;

@@ -65,16 +65,14 @@ public:
    template < class Edge, class Graph >
    void tree_out_edge(Edge e, const Graph& g) const
    {
-        typename graph_traits< Graph >::vertex_descriptor u = source(e, g),
-                                                          v = target(e, g);
+        auto u = source(e, g), v = target(e, g);
        put(m_distance, v, get(m_distance, u) + 1);
        put(m_predecessor, v, u);
    }
    template < class Edge, class Graph >
    void tree_in_edge(Edge e, const Graph& g) const
    {
-        typename graph_traits< Graph >::vertex_descriptor u = source(e, g),
-                                                          v = target(e, g);
+        auto u = source(e, g), v = target(e, g);
        put(m_distance, u, get(m_distance, v) + 1);
        put(m_predecessor, u, v);
    }
@@ -112,8 +112,8 @@ int main()
    add_edge(3, 4, EdgeProperty("harry"), g);
    add_edge(0, 1, EdgeProperty("chandler"), g);

-    property_map< graph_type, vertex_index_t >::type id = get(vertex_index, g);
-    property_map< graph_type, edge_name_t >::type name = get(edge_name, g);
+    auto id = get(vertex_index, g);
+    auto name = get(edge_name, g);

    graph_traits< graph_type >::vertex_iterator i, end;
    graph_traits< graph_type >::out_edge_iterator ei, edge_end;
@@ -49,7 +49,7 @@ int main(int argc, const char** argv)
    graph_traits< g_dot_type >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g_dot); ei != ei_end; ++ei)
    {
-        int weight = get(edge_weight, g_dot, *ei);
+        auto weight = get(edge_weight, g_dot, *ei);
        property< edge_weight_t, int > edge_property(weight);
        add_edge(source(*ei, g_dot), target(*ei, g_dot), edge_property, g);
    }
@@ -71,8 +71,8 @@ int main(int argc, const char** argv)

 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
    std::vector< int > distance(num_vertices(g));
-    property_map< Graph, edge_weight_t >::type weightmap = get(edge_weight, g);
-    property_map< Graph, vertex_index_t >::type indexmap = get(vertex_index, g);
+    auto weightmap = get(edge_weight, g);
+    auto indexmap = get(vertex_index, g);
    dijkstra_shortest_paths(g, router_six, &parent[0], &distance[0], weightmap,
        indexmap, std::less< int >(), closed_plus< int >(),
        (std::numeric_limits< int >::max)(), 0, default_dijkstra_visitor());
@@ -71,7 +71,7 @@ int main(int argc, char** argv)
    add_edge(5, 8, g);

    // Initialize the interior edge index
-    property_map< graph, edge_index_t >::type e_index = get(edge_index, g);
+    auto e_index = get(edge_index, g);
    graph_traits< graph >::edges_size_type edge_count = 0;
    graph_traits< graph >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
@@ -18,12 +18,12 @@ int main()
        Graph;
    typedef std::pair< int, int > E;
    const int num_nodes = 5;
-    E edges[]
+    const auto edges
        = { E(0, 2), E(1, 3), E(1, 4), E(2, 1), E(2, 3), E(3, 4), E(4, 0) };
    int weights[] = { 1, 1, 2, 7, 3, 1, 1 };
 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
    Graph g(num_nodes);
-    property_map< Graph, edge_weight_t >::type weightmap = get(edge_weight, g);
+    auto weightmap = get(edge_weight, g);
    for (std::size_t j = 0; j < sizeof(edges) / sizeof(E); ++j)
    {
        graph_traits< Graph >::edge_descriptor e;
@@ -32,14 +32,13 @@ int main()
        weightmap[e] = weights[j];
    }
 #else
-    Graph g(edges, edges + sizeof(edges) / sizeof(E), weights, num_nodes);
+    Graph g(std::begin(edges), std::end(edges), weights, num_nodes);
 #endif
    std::vector< graph_traits< Graph >::vertex_descriptor > p(num_vertices(g));

 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
-    property_map< Graph, vertex_distance_t >::type distance
-        = get(vertex_distance, g);
-    property_map< Graph, vertex_index_t >::type indexmap = get(vertex_index, g);
+    auto distance = get(vertex_distance, g);
+    auto indexmap = get(vertex_index, g);
    prim_minimum_spanning_tree(g, *vertices(g).first, &p[0], distance,
        weightmap, indexmap, default_dijkstra_visitor());
 #else
@@ -30,21 +30,20 @@ int main()
        property< edge_weight_t, int > >
        Graph;
    Graph g(num_vertices(g_dot));
-    property_map< GraphvizGraph, edge_attribute_t >::type edge_attr_map
-        = get(edge_attribute, g_dot);
+    auto edge_attr_map = get(edge_attribute, g_dot);
    graph_traits< GraphvizGraph >::edge_iterator ei, ei_end;
    for (boost::tie(ei, ei_end) = edges(g_dot); ei != ei_end; ++ei)
    {
-        int weight = lexical_cast< int >(edge_attr_map[*ei]["label"]);
+        auto weight = lexical_cast< int >(edge_attr_map[*ei]["label"]);
        property< edge_weight_t, int > edge_property(weight);
        add_edge(source(*ei, g_dot), target(*ei, g_dot), edge_property, g);
    }

    typedef graph_traits< Graph >::vertex_descriptor Vertex;
    std::vector< Vertex > parent(num_vertices(g));
-    property_map< Graph, edge_weight_t >::type weight = get(edge_weight, g);
+    auto weight = get(edge_weight, g);
 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
-    property_map< Graph, vertex_index_t >::type indexmap = get(vertex_index, g);
+    auto indexmap = get(vertex_index, g);
    std::vector< std::size_t > distance(num_vertices(g));
    prim_minimum_spanning_tree(g, *vertices(g).first, &parent[0], &distance[0],
        weight, indexmap, default_dijkstra_visitor());
@@ -53,12 +52,12 @@ int main()
 #endif

    int total_weight = 0;
-    for (int v = 0; v < num_vertices(g); ++v)
+    for (std::size_t v = 0; v < num_vertices(g); ++v)
        if (parent[v] != v)
            total_weight += get(weight, edge(parent[v], v, g).first);
    std::cout << "total weight: " << total_weight << std::endl;

-    for (int u = 0; u < num_vertices(g); ++u)
+    for (std::size_t u = 0; u < num_vertices(g); ++u)
        if (parent[u] != u)
            edge_attr_map[edge(parent[u], u, g_dot).first]["color"] = "black";
    std::ofstream out("figs/telephone-mst-prim.dot");
@@ -17,7 +17,7 @@ int main()
        graph_t;
    graph_t g;
    graph_traits< graph_t >::vertex_descriptor u = add_vertex(g);
-    property_map< graph_t, vertex_name_t >::type name_map = get(vertex_name, g);
+    auto name_map = get(vertex_name, g);
    name_map[u] = "Joe";
    std::cout << name_map[u] << std::endl;
    return EXIT_SUCCESS;
@@ -106,14 +106,12 @@ int main(int argc, char* argv[])
    std::cout << write(graph);

    std::cout << "radii:" << std::endl;
-    graph_property_iter_range< Graph, radius_t >::type seqRadius
-        = get_property_iter_range(graph, radius_t());
+    auto seqRadius = get_property_iter_range(graph, radius_t());
    std::for_each(seqRadius.first, seqRadius.second, Print());
    std::cout << std::endl;

    std::cout << "stiff:" << std::endl;
-    graph_property_iter_range< Graph, stiff_t >::type seqStiff
-        = get_property_iter_range(graph, stiff_t());
+    auto seqStiff = get_property_iter_range(graph, stiff_t());
    std::for_each(seqStiff.first, seqStiff.second, Print());
    std::cout << std::endl;

@@ -56,20 +56,17 @@ int main()
        Graph;
    Graph g;

-    property_map< Graph, edge_capacity_t >::type capacity
-        = get(edge_capacity, g);
-    property_map< Graph, edge_residual_capacity_t >::type residual_capacity
-        = get(edge_residual_capacity, g);
-    property_map< Graph, edge_reverse_t >::type rev = get(edge_reverse, g);
+    auto capacity = get(edge_capacity, g);
+    auto residual_capacity = get(edge_residual_capacity, g);
+    auto rev = get(edge_reverse, g);
    Traits::vertex_descriptor s, t;
    read_dimacs_max_flow(g, capacity, rev, s, t);

 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
-    property_map< Graph, vertex_index_t >::type indexmap = get(vertex_index, g);
-    long flow = push_relabel_max_flow(
+    auto flow = push_relabel_max_flow(
        g, s, t, capacity, residual_capacity, rev, indexmap);
 #else
-    long flow = push_relabel_max_flow(g, s, t);
+    auto flow = push_relabel_max_flow(g, s, t);
 #endif

    std::cout << "c  The total flow:" << std::endl;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jeremy W. Murphy	a477d6d787	Remove Boost::geometry from CMakeLists	2025-10-28 07:47:13 +09:00
Jeremy W. Murphy	5464928d0f	Add Boost.Geometry to CMakeList.txt	2025-10-14 07:44:21 +09:00
Jeremy W. Murphy	d4e2ba1802	Add Boost.Geometry to b2 dependencies	2025-10-14 07:40:24 +09:00
Jeremy W. Murphy	6c78c84156	Merge pull request #440 from boostorg/fix-GHA Remove old platforms	2025-10-09 16:54:49 +09:00
Jeremy W. Murphy	a94c7056e2	Remove old platforms Primarily Windows-2019, but also MacOS 13.	2025-10-08 08:58:40 +09:00
Jeremy W. Murphy	2eb59d35a7	Merge pull request #439 from Flamefire/fix-cmake-version Bump required CMake version to 3.8	2025-10-01 18:14:28 +09:00
Alexander Grund	4b521fe624	Fix required CMake version	2025-10-01 10:17:42 +02:00
Jeremy W. Murphy	46559d7a6e	Merge pull request #438 from Becheler/patch-1 Update iohb.c to use snprintf	2025-08-25 14:39:14 +09:00
Arnaud Becheler	d10b83cedd	Update iohb.c to use snprintf Use snprintf if available as some compilers (clang 14.0) issue deprecation warnings for sprintf, see issue #437	2025-08-24 21:15:47 +02:00
Jeremy W. Murphy	1cfeb9ad6b	Merge pull request #432 from andrea-cassioli-maersk/rcsp-visitor-docs Update r_c_shortest_paths.html	2025-07-18 12:08:04 +09:00
Andrea Cassioli	6df9717c84	Update doc/r_c_shortest_paths.html Co-authored-by: Jeremy W. Murphy <jeremy.william.murphy@gmail.com>	2025-07-17 11:28:45 +02:00
Andrea Cassioli	7e1863ae10	Update r_c_shortest_paths.html Add few details about the on_enter_loop visitor event that is not documented	2025-07-10 15:32:02 +02:00
Jeremy W. Murphy	3784692731	Merge pull request #429 from jan-grimo/fix-github-428 Fix multiplicity value comparison	2025-05-12 17:55:19 +09:00
Jan-Grimo Sobez	4697f3fb19	Update file paths	2025-05-09 22:07:47 +02:00
Jan-Grimo Sobez	4aec705625	Merge branch 'develop' into fix-github-428	2025-05-06 07:20:19 +02:00
Jeremy W. Murphy	acc19514d7	Remove ancient compilers and 2a versions	2025-05-02 13:26:28 +09:00
Jeremy W. Murphy	f2f55c2062	Merge pull request #382 from grafikrobot/modular Add support for modular build structure.	2025-05-02 13:23:31 +09:00
Rene Rivera	4951181a2e	Translate the compioler install name to the CXX command for B2.	2025-05-01 22:37:02 -05:00
Rene Rivera	7b7ab3f917	Update GHA CI to latest OSes and compilers.	2025-05-01 22:17:51 -05:00
Rene Rivera	7b9640389c	Sync from upstream.	2025-05-01 21:44:03 -05:00
Jan-Grimo Sobez	f434208542	Fix multiplicity value comparison Fix multiplicity value comparison - Replacement of at() in `8f3139be` as part of #349 was faulty: Iterator deref is a (key, value) pair, but only the value should be compared	2025-05-01 16:32:43 +02:00
Jeremy W. Murphy	34f3587678	Merge pull request #427 from jorisvr/iss426 Specify path of weighted_matching.dat via Jamfile	2025-04-30 19:33:33 +09:00
Rene Rivera	e9a12bb577	Move include to target.	2025-04-17 08:50:26 -05:00
Rene Rivera	823e17fb44	Tests no longer depend on Boost.Assign.	2025-04-12 23:10:50 -05:00
Joris van Rantwijk	be7434e584	Specify path of weighted_matching.dat via Jamfile	2025-04-05 12:02:25 +02:00
Rene Rivera	258f47a3b1	Sync from upstream.	2025-04-04 21:39:36 -05:00
Jeremy W. Murphy	cbae97953a	Merge pull request #421 from murraycu/develop-murrayc-examples-modern-cpp-attempt2 examples: C++11: Some use of range-based for loops	2025-03-12 19:07:32 +09:00
Jeremy W. Murphy	9bed95c45c	Merge pull request #424 from murraycu/develop-murrayc-examples-modern-cpp-attempt2d examples: C++11: Use std::begin() and std::end()	2025-03-10 08:11:56 +09:00
Murray Cumming	d93f67d804	examples: C++11: Use std::begin() and std::end() Instead of array + length. And use initializer lists.	2025-03-09 18:49:52 +01:00
Murray Cumming	6ebdc2c8fd	examples: C++11: Some use of range-based for loops	2025-03-09 18:21:54 +01:00
Jeremy W. Murphy	4792e04be7	Merge pull request #408 from samolisov/dominator-tree-vector-of-structs Aggregate predecessor state for Lengauer-Tarjan Improves performance on several benchmarks although regresses on one.	2025-03-04 22:19:26 +09:00
Pavel Samolysov	7b04334601	Rename preds -> pred	2025-03-04 13:43:27 +03:00
Pavel Samolysov	57058f091a	Combine the preds_of_n's components update into a whole	2025-03-01 17:05:04 +03:00
Pavel Samolysov	e936b09340	Add a test case for adjacency_matrix	2025-03-01 16:29:06 +03:00
Pavel Samolysov	38b4f317a8	Add a test case for adjacency_list< listS, vecS, bidirectionalS > This specialization of the adjacency_list class uses different value for `graph_traits< G >::null_vertex()`.	2025-03-01 14:21:49 +03:00
Pavel Samolysov	561e377199	.clang-format Enable adding a blank line between template and class name	2025-03-01 14:21:49 +03:00
Pavel Samolysov	e121340571	Address the comments from @jeremy-murphy Closes #383	2025-03-01 14:21:49 +03:00
Pavel Samolysov	3de9380d48	Remove the 'set_' members from 'preds' struct	2025-03-01 14:21:49 +03:00
Pavel Samolysov	8119d0e169	Use vector-of-structs of preds/semi for Lengauer-Tarjan Closes #383	2025-03-01 14:21:49 +03:00
Jeremy W. Murphy	9237081239	Merge pull request #403 from Wavetrace/feature-matrix-bidir Make adjacency_matrix implement BidirectionalGraph concept	2025-02-28 16:07:00 +09:00
Jeremy W. Murphy	50d26818e0	Fix comments for degree functions	2025-02-28 14:56:13 +09:00
Jeremy W. Murphy	8f05ca23fa	Merge pull request #410 from Tuxliri/patch-1 Fixed wrong link in grid_graph documentation	2025-02-27 07:11:09 +09:00
Jeremy W. Murphy	8a2d0439e4	Merge pull request #422 from murraycu/develop-murrayc-examples-modern-cpp-attempt2b examples: C++11: Use list initialization instead of push_back()	2025-02-20 20:13:07 +11:00
Jeremy W. Murphy	d5531e24dc	Merge pull request #418 from gogagum/feature/remove-boost-bind-usages Remove Boost.Bind usages, replace with lambda	2025-02-18 18:50:34 +11:00
Georgy Guminov	2d182cff02	Remove all std::bind usages.	2025-02-17 21:13:30 +03:00
Georgy Guminov	4aadc91f5c	Remove Boost.Bind usages. Fix build for clang.	2025-02-17 21:13:28 +03:00
Murray Cumming	5dbdc5546a	examples: C++11: Use list initialization instead of push_back()	2025-02-16 11:58:27 +01:00
Jeremy W. Murphy	167ac18ae7	Merge pull request #400 from jorisvr/matching_joris Replace implementation of maximum_weighted_matching() Based on a paper by Zvi Galil. The new code runs in time O(V^3).	2025-02-10 11:26:52 +09:00
Jeremy W. Murphy	84eaec81ec	Merge pull request #416 from gogagum/feature/remove-boost-assign-usages Remove Boost.Assign usages.	2025-02-10 11:11:59 +09:00
Joris van Rantwijk	6d9f2391b8	Use reference arguments instead of pointers	2025-02-06 22:59:40 +01:00
Joris van Rantwijk	dc9886b1cd	Avoid space after "!" operator	2025-02-06 22:25:40 +01:00
Joris van Rantwijk	ef60a858a5	Use auto for local variables	2025-02-06 22:11:35 +01:00
Joris van Rantwijk	cbcefb2db0	Avoid const member variables	2025-02-06 21:33:22 +01:00
Joris van Rantwijk	8600b33b5a	Use pointer instead of reference member variable	2025-02-06 20:21:40 +01:00
Joris van Rantwijk	3db393b6fd	Remove unnused #include	2025-02-06 20:09:38 +01:00
Georgy Guminov	8696a1fdc2	Remove Boost.Assign usages.	2025-02-06 00:43:03 +03:00
Joris van Rantwijk	69f393a08b	Rewrite "typedef" as "using" Also remove unnecessary < > spaces around template arguments.	2025-02-05 21:12:34 +01:00
Joris van Rantwijk	6396f826d3	Remove random test cases	2025-02-05 19:21:39 +01:00
Jeremy W. Murphy	cbb91297ca	Merge pull request #415 from AnthonyVH/anthonyvh/fix_named_graph_copy Ensure named_graph base class is initialized before accessing it	2025-02-04 21:10:47 +11:00
Anthony Van Herrewege	1c295e6830	Ensure named_graph base class is initialized before accessing it	2025-02-03 15:36:24 +01:00
Jeremy W. Murphy	254d7cbb24	Merge pull request #411 from murraycu/develop-murrayc-examples-modern-cpp-attempt2 examples: C++11: Use auto	2025-02-03 17:05:51 +11:00
Murray Cumming	f4d50aa424	examples: C++11: Use auto	2025-02-02 16:05:33 +01:00
Joris van Rantwijk	88a4f855f2	Clarify algorithm doc after review	2025-01-31 08:29:08 +01:00
Joris van Rantwijk	13c5fd7011	Remove verification code	2025-01-30 19:25:50 +01:00
Peter Dimov	f29296306f	Add missing include	2025-01-28 02:02:12 +02:00
Jeremy W. Murphy	84c36ca5f9	Merge pull request #412 from jeremy-murphy/388_is_straight_line_drawing Fix geometry bug in is_straight_line_drawing	2025-01-27 08:22:46 +11:00
Joris van Rantwijk	26efe6629e	Fix grammar in doc after review	2025-01-26 12:08:29 +01:00
Joris van Rantwijk	fa388e2784	Fix include order after review	2025-01-26 12:05:38 +01:00
Joris van Rantwijk	c8bd42dd53	Fix include order after review	2025-01-26 12:04:59 +01:00
Jeremy W. Murphy	80e00c358d	Merge pull request #414 from Flamefire/patch-1 Fix GHA build status badges in Readme	2025-01-22 22:11:43 +11:00
Alexander Grund	df1666e57a	Fix GHA build status badges in Readme	2025-01-22 11:13:56 +01:00
Jeremy W. Murphy	a372a07f0a	Merge pull request #413 from AnthonyVH/anthonyvh/fix_reserve_performance Fix performance issues for vector-based storage Also remove requirement for a mutable graph on vertex_by_property().	2025-01-22 20:11:39 +11:00
Anthony Van Herrewege	15b587adb8	Fix vector insertion complexity from O(N) to O(1)	2025-01-16 11:49:58 +01:00
Anthony Van Herrewege	9096f61b27	Allow getting vertex property from const graph object	2025-01-16 11:49:58 +01:00
Joris van Rantwijk	5fa8626155	Add weighted_matching_example to Jamfile	2025-01-13 21:35:19 +01:00
Joris van Rantwijk	059365ffe8	Update maximum_weighted_matching documentation	2025-01-13 21:35:19 +01:00
Joris van Rantwijk	fb66ac492f	Replace maximum_weighted_matching implementation The new code runs in O(V^3). It also solves a number of known issues.	2025-01-13 21:35:19 +01:00
Joris van Rantwijk	f30ba13a24	Add more tests for maximum_weighted_matching - Hand-picked graphs to explore basic functionality. - Graphs that are known to trigger bugs in the old implementation of maximum_weighted_matching(). - Random small graphs.	2025-01-13 21:32:38 +01:00
Jeremy W. Murphy	9176040132	Refactor the geometry details out into make and crosses	2025-01-02 09:35:40 +11:00
Jeremy W. Murphy	3244b38788	Use numeric_cast because size_t -> double is narrowing	2024-12-28 09:50:18 +11:00
Davide Iafrate	4d701e74f2	Fixed wrong link in grid_graph documentation	2024-12-25 12:43:59 +01:00
Jeremy W. Murphy	ce1daebc3d	Merge pull request #405 from murraycu/develop-murrayc-examples-modern-cpp-attempt2 Examples: Fix minor warnings	2024-12-21 08:30:02 +11:00
Jeremy W. Murphy	68b08e32a0	Merge pull request #407 from samolisov/dominator-tree-deque-to-vector Replace std::deque with std::vector for Lengauer-Tarjan	2024-12-21 08:27:48 +11:00
Pavel Samolysov	ca7741a8d8	Replace std::deque with std::vector for Lengauer-Tarjan Issue: #383	2024-12-19 13:39:44 +03:00
Jeremy W. Murphy	87b862c191	Fix #388 by using Boost.Geometry "crosses" fits the requirement as it means that the interior parts of the geometry share some common points, not exterior parts such as end-points, and it means "not within".	2024-12-19 08:43:00 +11:00
Murray Cumming	350e8d74c4	Examples: Avoid signed/unsigned comparison warnings.	2024-12-15 17:32:17 +01:00
Murray Cumming	c3868dcdb7	Example: Avoid unused variable warning.	2024-12-15 17:31:56 +01:00
Peter Kerzum	b0be1f7087	Make adjacency_matrix implement BidirectionalGraph concept Adjacency matrix is by nature bidirectional and one can see that the concept was mostly implemented before. That implementation missed the degree function(s). These functions are implemented in this commit and the traversal_category is updated to meet the concept requirements. Tests are also added, though they are a bit shallow in the sense that they seem to omit intensive algorithms.	2024-12-12 03:33:26 +01:00
Jeremy W. Murphy	bdeaf549ec	Merge pull request #402 from jorisvr/fix_doc_vertex Fix time complexity spec of vertex()	2024-12-10 08:32:58 +11:00
Joris van Rantwijk	ce24b257ca	Fix time complexity spec of vertex()	2024-12-08 11:37:24 +01:00
Joris van Rantwijk	f98edae416	weighted_matching_test check input file Without this check, the test program declares all tests passed if it fails to open the input file.	2024-12-03 21:38:27 +01:00
Jeremy W. Murphy	33b6802023	Merge pull request #394 from tsnorri/fix/cycle-canceling-dispatch1-call Fix missing detail:: namespace qualification on call to cycle_canceling_dispatch1.	2024-11-19 23:51:59 +11:00
Tuukka Norri	98e541c930	Fix missing namespace name	2024-11-08 12:21:28 +02:00
Peter Dimov	f1e51a0857	Add CMake subdir and install tests to ci.yml	2024-11-07 10:36:23 +02:00
Jeremy W. Murphy	fdc6199b6d	Merge pull request #393 from JulienDelacroix/warning bron_kerbosch_all_cliques: Fix unused parameter/variable warnings	2024-11-01 16:14:55 +11:00
Julien DELACROIX	5c753bedae	Fix unused parameter/variable warnings	2024-10-31 17:27:35 +01:00
Jeremy W. Murphy	4d6a196d04	Merge pull request #390 from danielyxyang/fix/undirected_dfs fixed incorrect callbacks to finish_edge in undirected_dfs	2024-10-30 17:47:54 +11:00
Hermann Stamm-Wilbrandt	8a60b5a259	Merge branch 'boostorg:develop' into issue_is_straight_line_drawing	2024-10-12 19:37:00 +02:00
Hermann-SW	bda28c863a	add failing is_straight_line_drawing testcase	2024-10-12 19:35:43 +02:00
Rene Rivera	dabe257fda	Sync from upstream.	2024-10-10 08:42:09 -05:00
Daniel Yang	b671e3d5e6	added test for checking dfs_visitor callbacks in undirected_dfs	2024-10-09 09:29:28 +02:00
Daniel Yang	0b63c6896a	fixed advancement of the edge iterator	2024-10-09 08:44:02 +02:00
Daniel Yang	6f2e223c7d	fixed incorrect callbacks to finish_edge in undirected_dfs	2024-10-09 08:41:09 +02:00
Jeremy W. Murphy	d108c967a1	Fix Clang 7 std, remove 1z	2024-10-09 14:17:22 +11:00
Jeremy W. Murphy	ba3022a97d	Remove C++11 from GitHub Actions	2024-10-08 10:44:57 +11:00
Jeremy W. Murphy	8a52339716	Remove C++11 builds	2024-10-08 10:43:21 +11:00
Rene Rivera	ab1d87b956	Sync from upstream.	2024-09-24 23:21:30 -05:00
Jeremy W. Murphy	41c1c56860	Merge pull request #386 from brunom/patch-1 Update publications.html	2024-09-23 06:25:14 +10:00
Bruno Martinez	e0e3731ca6	Update publications.html	2024-09-22 12:22:44 -03:00
Rene Rivera	f76084c5b8	Sync from upstream.	2024-09-14 08:39:44 -05:00
Jeremy W. Murphy	98019df3fd	Merge pull request #385 from boostorg/disjoint_set_doc_fixes Fix issue #384: broken links between disjoint_sets and incremental connected components	2024-09-12 09:54:26 +10:00
Jeremy W. Murphy	41d39a5162	Update disjoint_sets.html Remove unnecessary dir prefix	2024-09-12 09:51:00 +10:00
Jeremy W. Murphy	3184d9a084	Fix broken link to disjoint_sets	2024-09-12 09:49:54 +10:00
Jeremy W. Murphy	212451425d	Fix broken links to incremental components	2024-09-12 09:43:39 +10:00
Rene Rivera	df399ee1ed	Change math dep real target math/tr1.	2024-08-11 09:23:25 -05:00
Rene Rivera	a9516ad819	Update build deps.	2024-08-03 12:29:04 -05:00
Rene Rivera	82a4c4e9ca	Split b2 dependencies into public and private.	2024-07-26 13:03:51 -05:00
Rene Rivera	a40316edea	Move inter-lib dependencies to a project variable and into the build targets.	2024-07-23 22:34:22 -05:00
Rene Rivera	325f5b7921	Bump B2 require to 5.2	2024-06-14 11:33:55 -05:00
Rene Rivera	6b09e7b7e3	Sync from upstream.	2024-05-10 20:46:30 -05:00
Rene Rivera	41e8999121	Add requires-b2 check to top-level build file.	2024-05-05 09:00:01 -05:00
Rene Rivera	a5b6c4aeec	Sync from upstream.	2024-05-02 22:46:35 -05:00
Rene Rivera	4857f12f7a	Fix NO_LIB property syntax.	2024-04-28 21:45:45 -05:00
Rene Rivera	3f2414abd2	Add missing NO_LIB usage requirements.	2024-04-28 20:15:20 -05:00
Rene Rivera	e0d11417c5	Sync from upstream.	2024-04-20 15:32:18 -05:00
Rene Rivera	fe90a5b067	Sync from upstream.	2024-04-10 07:56:28 -05:00
Rene Rivera	e2547c2137	Switch to library requirements instead of source. As source puts extra source in install targets.	2024-03-29 21:15:59 -05:00
Rene Rivera	3d5eba2410	Make the library modular usable.	2024-03-11 08:38:17 -05:00