Merge pull request #164 from boostorg/develop

merge develop to master for release

.gitignore

@@ -0,0 +1,8 @@
+cube-fr.dot
+cube.dot
+disconnected-fr.dot
+graphml_test_out.xml
+kevin-bacon2.dat
+random.dot
+triangular-fr.dot
+triangular-kk.dot

.travis.yml

@@ -1,65 +1,298 @@
-# Use, modification, and distribution are
-# subject to the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#
-# Mael Valais, 2016
-# This travis file has been inspired from boostorg/geometry/circle.yml.
-#
-# This file is intended to make use of travis-ci, a continuous integration
-# service. The purpose is to build and run the tests on the graph module
-# on every push, and be able to know if those commits are "clean" or if
-# they break the build.
-#
-
-# I think that we shouldn't restrict on branches: PRs must also be tested
-# So for now, I disabled the "only on branches" feature
-#branches:
-#  only:
-#    - master
-#    - develop
-#    - test
+# Copyright 2016, 2017 Peter Dimov
+# Copyright 2018 Joh Maddock
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
 
 language: cpp
-compiler: gcc
+
+python: "2.7"
+
+os:
+  - linux
+  - osx
+
+branches:
+  only:
+    - master
+    - develop
+    - /feature\/.*/
 
 env:
-  global:
-    - BOOST_BRANCH=$([[ "$TRAVIS_BRANCH" = "master" ]] && echo master || echo develop)
-    - BOOST=boost-local # must be different from graph/boost dir name
-addons:
-  apt:
-    sources: ubuntu-toolchain-r-test
-    packages: g++-4.8
+  matrix:
+    - BOGUS_JOB=true
 
-before_install:
-  # Clone boost repository
-  - cd
-  - mkdir $BOOST && cd $BOOST
-  - git init .
-  - git remote add --no-tags -t $BOOST_BRANCH origin https://github.com/boostorg/boost.git
-  - git fetch --depth=1
-  - git checkout $BOOST_BRANCH
-  - git submodule update --init --merge
-  - git remote set-branches --add origin $BOOST_BRANCH
-  - git pull --recurse-submodules
-  - git submodule update --init
-  - git checkout $BOOST_BRANCH
-  - git submodule foreach "git reset --quiet --hard; git clean -fxd"
-  - git reset --hard; git clean -fxd
-  - git status
+matrix:
 
-  # replace the content of the library with the currently tested repo
-  - cd && pwd && ls
-  - rm -rf $BOOST/libs/graph
-  - cd $TRAVIS_BUILD_DIR && cd ..
-  - mv graph $HOME/$BOOST/libs/
+  exclude:
+    - env: BOGUS_JOB=true
 
-  # build b2 and create headers
-  - cd && cd $BOOST
+  include:
+    - os: linux
+      compiler: g++-4.4
+      env: TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.4
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.6
+      env: TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=14,1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=14,17
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: g++-8
+      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: g++-8
+      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=14,17
+      addons:
+        apt:
+          packages:
+            - g++-8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.5
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.5
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.6
+
+    - os: linux
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
+    
+    # Fails to compile std lib headers (toolset issue):
+    #- os: linux
+    #  env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
+    #  addons:
+    #    apt:
+    #      packages:
+    #        - clang-3.8
+    #      sources:
+    #        - ubuntu-toolchain-r-test
+    #        - llvm-toolchain-precise-3.8
+    #
+    #- os: linux
+    #  env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
+    #  addons:
+    #    apt:
+    #      packages:
+    #        - clang-3.9
+    #      sources:
+    #        - ubuntu-toolchain-r-test
+    #        - llvm-toolchain-precise-3.9
+
+    - os: linux
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,1z
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
+
+    - os: linux
+      compiler: clang++-5.0
+      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-5.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+
+    - os: linux
+      compiler: clang++-5.0
+      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=14,1z
+      addons:
+        apt:
+          packages:
+            - clang-5.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03
+      osx_image: xcode7.3
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=11
+      osx_image: xcode7.3
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=14,1z
+      osx_image: xcode7.3
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03
+      osx_image: xcode8.3
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=11
+      osx_image: xcode8.3
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=14,1z
+      osx_image: xcode8.3
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03
+      osx_image: xcode9.4.1
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=11
+      osx_image: xcode9.4.1
+
+    - os: osx
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=14,1z
+      osx_image: xcode9.4.1
+
+
+install:
+  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+  - cd ..
+  - git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule update --init tools/boost_install
+  - git submodule update --init libs/headers
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init tools/boostdep
+  - cp -r $TRAVIS_BUILD_DIR/* libs/graph
+  - python tools/boostdep/depinst/depinst.py graph
   - ./bootstrap.sh
   - ./b2 headers
 
-# This part is meant for unit tests
+
 script:
-  - cd $HOME/$BOOST/libs/graph/test
-  - ../../../b2 toolset=gcc-4.8 cxxflags=-std=c++11
+  - |-
+    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+  - IFS=','
+  - for CXXLOCAL in $CXXSTD; do  (cd libs/config/test && ../../../b2 config_info_travis_install toolset=$TOOLSET cxxstd=$CXXLOCAL && ./config_info_travis && rm ./config_info_travis)  done
+  - unset IFS
+  - ./b2 -j3 libs/graph/test toolset=$TOOLSET cxxstd=$CXXSTD
+
+notifications:
+  email:
+    on_success: always

appveyor.yml

@@ -0,0 +1,64 @@
+# Copyright 2016 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+  only:
+    - master
+    - develop
+
+platform:
+  - x64
+
+environment:
+  matrix:
+    - ARGS: --toolset=msvc-9.0  address-model=32
+    - ARGS: --toolset=msvc-10.0 address-model=32
+    - ARGS: --toolset=msvc-11.0 address-model=32
+    - ARGS: --toolset=msvc-12.0 address-model=32
+    - ARGS: --toolset=msvc-14.0 address-model=32
+    - ARGS: --toolset=msvc-12.0 address-model=64
+    - ARGS: --toolset=msvc-14.0 address-model=64
+    - ARGS: --toolset=msvc-14.0 address-model=64 cxxflags=-std:c++latest
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      ARGS: --toolset=msvc-14.1 address-model=64
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      ARGS: --toolset=msvc-14.1 address-model=32
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      ARGS: --toolset=msvc-14.1 address-model=64 cxxflags=-std:c++latest
+    - ARGS: --toolset=gcc address-model=64
+      PATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;%PATH%
+    - ARGS: --toolset=gcc address-model=64 cxxflags=-std=gnu++1z
+      PATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;%PATH%
+    - ARGS: --toolset=gcc address-model=32
+      PATH: C:\mingw-w64\i686-5.3.0-posix-dwarf-rt_v4-rev0\mingw32\bin;%PATH%
+    - ARGS: --toolset=gcc address-model=32 linkflags=-Wl,-allow-multiple-definition
+      PATH: C:\MinGW\bin;%PATH%
+
+
+install:
+  - cd ..
+  - git clone -b %APPVEYOR_REPO_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule update --init tools/boost_install
+  - git submodule update --init libs/headers
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\graph
+  - git submodule update --init tools/boostdep
+  - python tools/boostdep/depinst/depinst.py graph
+  - bootstrap
+  - b2 headers
+
+build: off
+
+test_script:
+  - cd libs\config\test
+  - ..\..\..\b2 config_info_travis_install %ARGS%
+  - config_info_travis
+  - cd ..\..\graph\test
+  - ..\..\..\b2 -j3 --hash %ARGS%

doc/AStarHeuristic.html

@@ -32,7 +32,7 @@ href="./astar_search.html">astar_search()</a>.
 
 <h3>Refinement of</h3>
 
-<a href="http://www.sgi.com/tech/stl/UnaryFunction.html">Unary
+<a href="http://www.boost.org/sgi/stl/UnaryFunction.html">Unary
 Function</a> (must take a single argument -- a graph vertex -- and
 return a cost value) and <a
 href="../../utility/CopyConstructible.html">Copy Constructible</a>
@@ -129,7 +129,7 @@ Called for the target of every out edge of a vertex being examined.
 <TABLE>
 <TR valign=top>
 <TD nowrap>Copyright &copy; 2004</TD><TD>
-<A HREF="http://www.cs.rpi.edu/~beevek/">Kristopher Beevers</A>,
+<A HREF="http://cs.krisbeevers.com/">Kristopher Beevers</A>,
 Rensselaer Polytechnic Institute (<A
 HREF="mailto:beevek@cs.rpi.edu">beevek@cs.rpi.edu</A>)
 </TD></TR></TABLE>

doc/AStarVisitor.html

@@ -204,7 +204,7 @@ happens after all of its out-edges have been examined.
 <TABLE>
 <TR valign=top>
 <TD nowrap>Copyright &copy; 2004</TD><TD>
-<A HREF="http://www.cs.rpi.edu/~beevek/">Kristopher Beevers</A>,
+<A HREF="http://cs.krisbeevers.com/">Kristopher Beevers</A>,
 Rensselaer Polytechnic Institute (<A
 HREF="mailto:beevek@cs.rpi.edu">beevek@cs.rpi.edu</A>)
 </TD></TR></TABLE>

doc/BFSVisitor.html

@@ -211,7 +211,7 @@ class count_tree_edges_bfs_visitor(bgl.Graph.BFSVisitor):
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/BellmanFordVisitor.html

@@ -175,7 +175,7 @@ class count_tree_edges_bellman_ford_visitor(bgl.Graph.BellmanFordVisitor):
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/Buffer.html

@@ -45,7 +45,7 @@ For a type to model the Buffer concept it must have the following members.
 
 <tr> <td> <tt>value_type</tt> </td> 
      <td> The type of object stored in the Buffer. The value type
-          must be <A href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>.</td>
+          must be <A href="http://www.boost.org/sgi/stl/Assignable.html">Assignable</a>.</td>
     </tr>
 
 <tr> <td> <tt>size_type</tt>  </td>
@@ -99,7 +99,7 @@ most linear time complexity in the size of the Generalized Queue.
 <h3>Models</h3>
 
 <UL>
-<LI><a href="http://www.sgi.com/tech/stl/stack.html"><tt>std::stack</tt></a>
+<LI><a href="http://www.boost.org/sgi/stl/stack.html"><tt>std::stack</tt></a>
 <LI><a href="../../../boost/pending/mutable_queue.hpp"><tt>boost::mutable_queue</tt></a>
 </UL>
 

doc/ColorValue.html

@@ -28,9 +28,9 @@ mark which vertices have been visited.
 <P>
 
 <h3>Refinement of</h3> <a
-href="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</a>
+href="http://www.boost.org/sgi/stl/EqualityComparable.html">EqualityComparable</a>
 and <a
-href="http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a>
+href="http://www.boost.org/sgi/stl/DefaultConstructible.html">DefaultConstructible</a>
 
 
 <h3>Notation</h3>
@@ -99,7 +99,7 @@ href="http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructibl
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/DFSVisitor.html

@@ -212,7 +212,7 @@ class count_tree_edges_dfs_visitor(bgl.Graph.DFSVisitor):
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/DijkstraVisitor.html

@@ -213,7 +213,7 @@ class count_tree_edges_dijkstra_visitor(bgl.Graph.DijkstraVisitor):
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/EventVisitor.html

@@ -152,7 +152,7 @@ either a vertex or edge descriptor of the graph.
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/EventVisitorList.html

@@ -118,7 +118,7 @@ std::make_pair(<i>visitor1</i>,
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/Graph.html

@@ -24,7 +24,7 @@ The Graph concept contains a few requirements that are common to all
 the graph concepts. These include some associated types for
 <tt>vertex_descriptor</tt>, <tt>edge_descriptor</tt>, etc. One should
 note that a model of Graph is <B>not</B> required to be a model of <a
-href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>,
+href="http://www.boost.org/sgi/stl/Assignable.html">Assignable</a>,
 so algorithms should pass graph objects by reference.
 
 <P>
@@ -51,9 +51,9 @@ so algorithms should pass graph objects by reference.
 A vertex descriptor corresponds to a unique vertex in an abstract
 graph instance. A vertex descriptor must be
 <a
-href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default Constructible</a>,
-<a href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>, and
-<a href="http://www.sgi.com/tech/stl/EqualityComparable.html">Equality Comparable</a>.
+href="http://www.boost.org/sgi/stl/DefaultConstructible.html">Default Constructible</a>,
+<a href="http://www.boost.org/sgi/stl/Assignable.html">Assignable</a>, and
+<a href="http://www.boost.org/sgi/stl/EqualityComparable.html">Equality Comparable</a>.
 </td>
 </tr>
 
@@ -61,9 +61,9 @@ href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default Constructib
 <td><pre>boost::graph_traits&lt;G&gt;::edge_descriptor</pre>
 An edge descriptor corresponds to a unique edge <i>(u,v)</i> in a
 graph.  An edge descriptor must be <a
-href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default Constructible</I>,
-<a href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>, and
-<a href="http://www.sgi.com/tech/stl/EqualityComparable.html">Equality Comparable</a>.
+href="http://www.boost.org/sgi/stl/DefaultConstructible.html">Default Constructible</I>,
+<a href="http://www.boost.org/sgi/stl/Assignable.html">Assignable</a>, and
+<a href="http://www.boost.org/sgi/stl/EqualityComparable.html">Equality Comparable</a>.
 </td>
 </tr>
 

doc/IncidenceGraph.html

@@ -193,7 +193,7 @@ Therefore, the extra requirement is added that the out-edge connecting
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/IteratorConstructibleGraph.html

@@ -22,7 +22,7 @@ IteratorConstructibleGraph
 The IteratorConstructibleGraph concept describes the interface for
 graph types that can be constructed using a kind of edge iterator. The
 edge iterator can be any <a
-href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>
+href="http://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>
 that dereferences to a pair of integers <i>(i,j)</i>, which represent
 an edge that should be in the graph. The two integers <i>i</i> and
 <i>j</i> represent vertices where <i>0 <= i < |V|</i> and <i>0 <= j <
@@ -44,7 +44,7 @@ the second constructor can be more efficient than the first.
 The following exampe creates two graph objects from an array of edges
 (vertex pairs). The type <tt>Edge*</tt> satisfies the requirements for
 an <a
-href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>
+href="http://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>
 and can therefore be used to construct a graph.
 
 <pre>
@@ -152,7 +152,7 @@ constructor lacking the graph size information.
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/Monoid.html

@@ -33,7 +33,7 @@ The element type must be a model of <a
 href="../../utility/Assignable.html">Assignable</a> and <a
 href="../../utility/CopyConstructible.html">CopyConstructible</a>.
 The function object type must be a model of <a
-href="http://www.sgi.com/tech/stl/BinaryFunction.html">BinaryFunction</a>.
+href="http://www.boost.org/sgi/stl/BinaryFunction.html">BinaryFunction</a>.
 
 <h3>Notation</h3>
 
@@ -113,7 +113,7 @@ Return type: <TT>bool</TT>
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/MutableGraph.html

@@ -58,7 +58,7 @@ edges and vertices.
 <TR>
 <TD><tt>p</tt></TD>
 <TD>is an object of a type that models <a
-href="http://www.sgi.com/tech/stl/Predicate.html">Predicate</a>
+href="http://www.boost.org/sgi/stl/Predicate.html">Predicate</a>
 and whose argument type matches the <tt>edge_descriptor</tt> type. 
 </TR>
 

doc/PropertyTag.html

@@ -67,7 +67,7 @@ href="../../../boost/pending/property.hpp"><tt>boost/pending/property.hpp</tt></
 <h3>Refinement of</h3>
 
 <a
-href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default Constructible</a> 
+href="http://www.boost.org/sgi/stl/DefaultConstructible.html">Default Constructible</a> 
 
 
 <h3>Models</h3>

doc/VertexMutableGraph.html

@@ -28,7 +28,7 @@ implementation does the rest.
 <H3>Refinement of</H3>
 
 <a href="./Graph.html">Graph</a> and <a
-href="http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a>
+href="http://www.boost.org/sgi/stl/DefaultConstructible.html">DefaultConstructible</a>
 
 <H3>Associated Types</H3>
 

doc/acknowledgements.html

@@ -67,7 +67,7 @@ Science of the U.S. Department of Energy.
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/adjacency_iterator.html

@@ -115,7 +115,7 @@ href="../../utility/MultiPassInputIterator.html">Multi-Pass Input Iterator</a>
 
 The adjacency iterator type implements the member functions and
 operators required of the <a
-href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access Iterator</a>
+href="http://www.boost.org/sgi/stl/RandomAccessIterator.html">Random Access Iterator</a>
 concept, except that the <tt>reference</tt> type is the same as the <tt>value_type</tt>
 so <tt>operator*()</tt> returns by-value. In addition it has the following constructor:
 

doc/adjacency_list.html

@@ -397,9 +397,9 @@ The type for the iterators returned by <TT>vertices()</TT>.
 
 When <tt>VertexList=vecS</tt> then the <tt>vertex_iterator</tt> models
 <a
-href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>. Otherwise
+href="http://www.boost.org/sgi/stl/RandomAccessIterator.html">RandomAccessIterator</a>. Otherwise
 the <tt>vertex_iterator</tt> models <a
-href="http://www.sgi.com/tech/stl/BidirectionalIterator.html">BidirectionalIterator</a>.
+href="http://www.boost.org/sgi/stl/BidirectionalIterator.html">BidirectionalIterator</a>.
 
 <hr>
 
@@ -407,7 +407,7 @@ href="http://www.sgi.com/tech/stl/BidirectionalIterator.html">BidirectionalItera
 <br><br>
 The type for the iterators returned by <TT>edges()</TT>.
 The <tt>edge_iterator</tt> models <a
-href="http://www.sgi.com/tech/stl/BidirectionalIterator.html">BidirectionalIterator</a>.
+href="http://www.boost.org/sgi/stl/BidirectionalIterator.html">BidirectionalIterator</a>.
 
 
 <hr>
@@ -418,13 +418,13 @@ href="http://www.sgi.com/tech/stl/BidirectionalIterator.html">BidirectionalItera
 
 The type for the iterators returned by <TT>out_edges()</TT>.
 When <tt>OutEdgeList=vecS</tt> then the <tt>out_edge_iterator</tt> models
-<a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">
+<a href="http://www.boost.org/sgi/stl/RandomAccessIterator.html">
 RandomAccessIterator</a>.  When <tt>OutEdgeList=slistS</tt> then the
 <tt>out_edge_iterator</tt> models <a
-href="http://www.sgi.com/tech/stl/ForwardIterator.html">
+href="http://www.boost.org/sgi/stl/ForwardIterator.html">
 ForwardIterator</a>.  Otherwise the <tt>out_edge_iterator</tt> models
 <a
-href="http://www.sgi.com/tech/stl/BidirectionalIterator.html">
+href="http://www.boost.org/sgi/stl/BidirectionalIterator.html">
 BidirectionalIterator</a>.
 
 <hr>
@@ -578,7 +578,7 @@ adjacency_list(EdgeIterator&nbsp;first, EdgeIterator&nbsp;last,
 Creates a graph object with <TT>n</TT> vertices and with the edges
 specified in the edge list given by the range <TT>[first, last)</TT>.
 The <tt>EdgeIterator</tt> must be a model of <a
-href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
+href="http://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>.
 The value type of the <TT>EdgeIterator</TT> must be a
 <TT>std::pair</TT>, where the type in the pair is an integer type. The
 integers will correspond to vertices, and they must all fall in the
@@ -599,7 +599,7 @@ Creates a graph object with <TT>n</TT> vertices and with the edges
 specified in the edge list given by the range <TT>[first, last)</TT>.
 The <tt>EdgeIterator</tt> and <tt>EdgePropertyIterator</tt> must be a
 model of <a
-href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
+href="http://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>.
 The value type of the <TT>EdgeIterator</TT> must be a
 <TT>std::pair</TT>, where the type in the pair is an integer type. The
 integers will correspond to vertices, and they must all fall in the
@@ -884,7 +884,7 @@ has time complexity <i>O(E/V)</i>.
 <hr>
 
 <pre>
-template &lt;class <a href="http://www.sgi.com/tech/stl/Predicate.html">Predicate</a>&gt;
+template &lt;class <a href="http://www.boost.org/sgi/stl/Predicate.html">Predicate</a>&gt;
 void remove_out_edge_if(vertex_descriptor u, Predicate predicate,
                         adjacency_list&amp; g)
 </pre>
@@ -899,7 +899,7 @@ invoking <tt>remove_edge()</tt> on each of the removed edges.
 
 <pre>
 template &lt;class <a
-href="http://www.sgi.com/tech/stl/Predicate.html">Predicate</a>&gt;
+href="http://www.boost.org/sgi/stl/Predicate.html">Predicate</a>&gt;
 void remove_in_edge_if(vertex_descriptor v, Predicate predicate,
                        adjacency_list&amp; g)
 </pre>
@@ -917,7 +917,7 @@ This operation is available for undirected and bidirectional
 <hr>
 
 <pre>
-template &lt;class <a href="http://www.sgi.com/tech/stl/Predicate.html">Predicate</a>&gt;
+template &lt;class <a href="http://www.boost.org/sgi/stl/Predicate.html">Predicate</a>&gt;
 void remove_edge_if(Predicate predicate, adjacency_list&amp; g)
 </pre>
 Removes all edges from the graph that satisfy
@@ -1127,7 +1127,7 @@ Include <a href="../../../boost/graph/adj_list_serialize.hpp"><tt>boost/graph/ad
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/adjacency_list_traits.html

@@ -79,8 +79,8 @@ The selector type whether the graph is directed or undirected.
 <h3>Model of</h3>
 
 <a
-href="http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a> and
-<a href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>
+href="http://www.boost.org/sgi/stl/DefaultConstructible.html">DefaultConstructible</a> and
+<a href="http://www.boost.org/sgi/stl/Assignable.html">Assignable</a>
 
 <h3>Type Requirements</h3>
 
@@ -149,7 +149,7 @@ parallel edges (<tt>disallow_parallel_edge_tag</tt>).
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/adjacency_matrix.html

@@ -237,7 +237,7 @@ The type for the edge descriptors associated with the
 <tt>graph_traits&lt;adjacency_matrix&gt;::vertex_iterator</tt>
 <br><br>
   The type for the iterators returned by <tt>vertices()</tt>.  
-  The vertex iterator models <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>. <br>
+  The vertex iterator models <a href="http://www.boost.org/sgi/stl/RandomAccessIterator.html">RandomAccessIterator</a>. <br>
  (Required by <a href="VertexListGraph.html">VertexListGraph</a>.)
 
 <hr>

doc/astar_heuristic.html

@@ -87,7 +87,7 @@ to a goal.
 <TABLE>
 <TR valign=top>
 <TD nowrap>Copyright &copy; 2004</TD><TD>
-<A HREF="http://www.cs.rpi.edu/~beevek/">Kristopher Beevers</A>,
+<A HREF="http://cs.krisbeevers.com/">Kristopher Beevers</A>,
 Rensselaer Polytechnic Institute (<A
 HREF="mailto:beevek@cs.rpi.edu">beevek@cs.rpi.edu</A>)
 </TD></TR></TABLE>

doc/astar_search.html

@@ -65,7 +65,7 @@ template <typename VertexListGraph, typename AStarHeuristic,
           typename CostMap, typename DistanceMap,
           typename WeightMap, typename VertexIndexMap,
 	  typename ColorMap,
-          typename <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">CompareFunction</a>, typename <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">CombineFunction</a>,
+          typename <a href="http://www.boost.org/sgi/stl/BinaryPredicate.html">CompareFunction</a>, typename <a href="http://www.boost.org/sgi/stl/BinaryFunction.html">CombineFunction</a>,
           typename CostInf, typename CostZero&gt;
 inline void
 astar_search
@@ -82,7 +82,7 @@ template &lt;typename VertexListGraph, typename AStarHeuristic,
           typename <a href="AStarVisitor.html">AStarVisitor</a>, typename PredecessorMap,
           typename CostMap, typename DistanceMap,
           typename WeightMap,
-          typename <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">CompareFunction</a>, typename <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">CombineFunction</a>,
+          typename <a href="http://www.boost.org/sgi/stl/BinaryPredicate.html">CompareFunction</a>, typename <a href="http://www.boost.org/sgi/stl/BinaryFunction.html">CombineFunction</a>,
           typename CostInf, typename CostZero&gt;
 inline void
 astar_search_tree
@@ -100,7 +100,7 @@ template &lt;typename IncidenceGraph, typename AStarHeuristic,
           typename CostMap, typename DistanceMap,
           typename WeightMap, typename ColorMap,
           typename VertexIndexMap,
-          typename <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">CompareFunction</a>, typename <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">CombineFunction</a>,
+          typename <a href="http://www.boost.org/sgi/stl/BinaryPredicate.html">CompareFunction</a>, typename <a href="http://www.boost.org/sgi/stl/BinaryFunction.html">CombineFunction</a>,
           typename CostInf, typename CostZero&gt;
 inline void
 astar_search_no_init
@@ -121,7 +121,7 @@ template &lt;typename IncidenceGraph, typename AStarHeuristic,
           typename <a href="AStarVisitor.html">AStarVisitor</a>, typename PredecessorMap,
           typename CostMap, typename DistanceMap,
           typename WeightMap,
-          typename <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">CompareFunction</a>, typename <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">CombineFunction</a>,
+          typename <a href="http://www.boost.org/sgi/stl/BinaryPredicate.html">CompareFunction</a>, typename <a href="http://www.boost.org/sgi/stl/BinaryFunction.html">CombineFunction</a>,
           typename CostInf, typename CostZero&gt;
 inline void
 astar_search_no_init_tree
@@ -394,7 +394,7 @@ UTIL/OUT: <tt>distance_map(DistanceMap d_map)</tt>
   href="./Monoid.html"><tt>Monoid</tt></a> formed with the
   <tt>combine</tt> function object and the zero object for the
   identity element.  Also the distance value type must have a <a
-  href="http://www.sgi.com/tech/stl/StrictWeakOrdering.html"><tt>StrictWeakOrdering</tt></a>
+  href="http://www.boost.org/sgi/stl/StrictWeakOrdering.html"><tt>StrictWeakOrdering</tt></a>
   provided by the <tt>compare</tt> function object.  A
   <tt>constant_writable_property_map</tt> returning the infinity value can be
   used for this parameter in tree versions of the algorithm when the graph does
@@ -424,7 +424,7 @@ UTIL/OUT: <tt>rank_map(CostMap c_map)</tt>
   href="./Monoid.html"><tt>Monoid</tt></a> formed with the
   <tt>combine</tt> function object and the zero object for the
   identity element.  Also the distance value type must have a <a
-  href="http://www.sgi.com/tech/stl/StrictWeakOrdering.html"><tt>StrictWeakOrdering</tt></a>
+  href="http://www.boost.org/sgi/stl/StrictWeakOrdering.html"><tt>StrictWeakOrdering</tt></a>
   provided by the <tt>compare</tt> function object.  The value type
   for this map must be the same as the value type for the distance
   map.  In tree versions of the algorithm, <tt>null_property_map</tt> can be
@@ -466,7 +466,7 @@ IN: <tt>distance_compare(CompareFunction cmp)</tt>
   is closer to the start vertex, and to compare <i>f</i>-values to
   determine which vertex on the OPEN list to examine next.  The
   <tt>CompareFunction</tt> type must be a model of <a
-  href="http://www.sgi.com/tech/stl/BinaryPredicate.html"><tt>Binary
+  href="http://www.boost.org/sgi/stl/BinaryPredicate.html"><tt>Binary
   Predicate</tt></a> and have argument types that match the value type
   of the <tt>DistanceMap</tt> property map.<br>
 
@@ -481,7 +481,7 @@ IN: <tt>distance_combine(CombineFunction cmb)</tt>
   of a path, and to combine distance and heuristic values to compute
   the <i>f</i>-value of a vertex.  The <tt>CombineFunction</tt> type
   must be a model of <a
-  href="http://www.sgi.com/tech/stl/BinaryFunction.html"><tt>Binary
+  href="http://www.boost.org/sgi/stl/BinaryFunction.html"><tt>Binary
   Function</tt></a>.  Both argument types of the binary function must
   match the value type of the <tt>DistanceMap</tt> property map (which
   is the same as that of the <tt>WeightMap</tt> and <tt>CostMap</tt>
@@ -580,7 +580,7 @@ this state by pointer or reference.
 <TABLE>
 <TR valign=top>
 <TD nowrap>Copyright &copy; 2004</TD><TD>
-<A HREF="http://www.cs.rpi.edu/~beevek/">Kristopher Beevers</A>,
+<A HREF="http://cs.krisbeevers.com/">Kristopher Beevers</A>,
 Rensselaer Polytechnic Institute (<A
 HREF="mailto:beevek@cs.rpi.edu">beevek@cs.rpi.edu</A>)
 </TD></TR></TABLE>

doc/astar_visitor.html

@@ -99,7 +99,7 @@ and <a href="./property_writer.html"><tt>property_writer</tt></a>.
 <TABLE>
 <TR valign=top>
 <TD nowrap>Copyright &copy; 2004</TD><TD>
-<A HREF="http://www.cs.rpi.edu/~beevek/">Kristopher Beevers</A>,
+<A HREF="http://cs.krisbeevers.com/">Kristopher Beevers</A>,
 Rensselaer Polytechnic Institute (<A
 HREF="mailto:beevek@cs.rpi.edu">beevek@cs.rpi.edu</A>)
 </TD></TR></TABLE>

doc/bc_clustering.html

@@ -142,7 +142,7 @@ IN: <tt>VertexIndexMap vertex_index</tt>
 <td nowrap>Copyright &copy; 2004</td>
 <td><a href="http://www.boost.org/people/doug_gregor.html">Douglas Gregor</a>,
 Indiana University (dgregor@cs.indiana.edu)<br>
-<a href="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</a>, Indiana
+<a href="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</a>, Indiana
 University (<a href=
 "mailto:lums@osl.iu.edu">lums@osl.iu.edu</a>)</td>
 </tr>

doc/bellman_ford_shortest.html

@@ -34,7 +34,7 @@ bool bellman_ford_shortest_paths(const VertexAndEdgeListGraph& g,
 <i>// non-named parameter version</i>
 template &lt;class <a href="./EdgeListGraph.html">EdgeListGraph</a>, class Size, class WeightMap,
 	  class PredecessorMap, class DistanceMap,
-	  class <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">BinaryFunction</a>, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>,
+	  class <a href="http://www.boost.org/sgi/stl/BinaryFunction.html">BinaryFunction</a>, class <a href="http://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>,
 	  class <a href="./BellmanFordVisitor.html">BellmanFordVisitor</a>&gt;
 bool bellman_ford_shortest_paths(EdgeListGraph&amp; g, Size N, 
   WeightMap weight, PredecessorMap pred, DistanceMap distance, 
@@ -236,7 +236,7 @@ IN/OUT: <tt>distance_map(DistanceMap d)</tt>
   Property Map</a>. The key type of the property map must be the
   vertex descriptor type of the graph, and the value type of the
   distance map must be <a
-  href="http://www.sgi.com/tech/stl/LessThanComparable.html"> Less
+  href="http://www.boost.org/sgi/stl/LessThanComparable.html"> Less
   Than Comparable</a>.<br> <b>Default:</b> <tt>get(vertex_distance,
   g)</tt><br>
   <b>Python</b>: Must be a <tt>vertex_double_map</tt> for the graph.<br>

doc/bellman_visitor.html

@@ -102,7 +102,7 @@ and <a href="./property_writer.html"><tt>property_writer</tt></a>.
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/betweenness_centrality.html

@@ -297,7 +297,7 @@ is <em>O(VE)</em>.
 <TR valign=top>
 <TD nowrap>Copyright &copy; 2004</TD><TD>
 <A HREF="http://www.boost.org/people/doug_gregor.html">Douglas Gregor</A>, Indiana University (dgregor@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/bfs_visitor.html

@@ -119,7 +119,7 @@ and <a href="./property_writer.html"><tt>property_writer</tt></a>.
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/bgl_named_params.html

@@ -87,7 +87,7 @@ like <tt>boost::weight_map</tt> that create an instance of
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/bibliography.html

@@ -148,7 +148,7 @@ J. W. H. Liu.
 
 <P></P><DT><A NAME="mehlhorn99:_leda">22</A>
 <DD>
-K.&nbsp;Mehlhorn and S.&nbsp;Näher.
+K.&nbsp;Mehlhorn and S.&nbsp;Näher.
 <BR><EM>The LEDA Platform of Combinatorial and Geometric Computing</EM>.
 <BR>Cambridge University Press, 1999.
 
@@ -438,6 +438,21 @@ David&nbsp;Bruce&nbsp;Wilson
 <BR><em>Generating random spanning trees more quickly than the cover time</em>.
 ACM Symposium on the Theory of Computing, pp. 296-303, 1996.
 
+<p></p><dt><a name="edmonds65:_max_weighted_match">74</a>
+<dd>J. Edmonds<br>
+<em>Maximum Matching and a Polyhedron with 0, 1-Vertices</em><br>
+Journal of Research of the National Bureau of Standards B 69, pp. 125-130, 1965.
+
+<p></p><dt><a name="gabow76">75</a>
+<dd>Harold N. Gabow<br>
+<em>An Efficient Implementation of Edmonds' Algorithm for Maximum Matching on Graphs</em><br>
+Journal of the ACM (JACM), 23(2): 221-234, 1976.
+
+<p></p><dt><a name="gabow90">76</a>
+<dd>Harold N. Gabow<br>
+<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.
+
 </dl>
   
 <br>

doc/challenge.html

@@ -61,12 +61,12 @@ polygons.</li>
 <li>Rewrite the Qhull algorithm using the Boost Graph Library (this is
 high difficulty challenge).  Or, for a more manageable challenge,
 write an interface for Qhull with the BGL.  <a
-href="http://www.geom.umn.edu/locate/qhull">Qhull</a> computes the
+href="http://www.qhull.org/">Qhull</a> computes the
 convex hull, Delaunay triangulation, Voronoi diagram, and halfspace
 intersection about a point.  Qhull runs in 2-d, 3-d, 4-d, and higher
 dimensions.  Qhull is used for collision detection, animation, plate
 tectonics, 3-d modeling, robot motion planning, and other <a
-href="http://www.geom.umn.edu/~bradb/qhull-news.html#use">applications</a>.
+href="http://www.qhull.org/news/qhull-news.html#users">applications</a>.
 It is currently difficult to use from a C++ program.
 
 </li>

doc/circle_layout.html

@@ -45,7 +45,7 @@ IN: <tt>Radius radius</tt>
 <TR valign=top>
 <TD nowrap>Copyright &copy; 2004</TD><TD>
 <A HREF="http://www.boost.org/people/doug_gregor.html">Douglas Gregor</A>, Indiana University (dgregor -at- cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (lums -at- osl.iu.edu)
 </TD></TR></TABLE>
                            </body></html>

doc/compressed_sparse_row.html

@@ -416,7 +416,7 @@ void <a href="#add_edges_sorted_prop">add_edges_sorted</a>(BidirectionalIterator
       edges are specified by the iterator range <code>[edge_begin,
       edge_end)</code>. The <tt>InputIterator</tt> must be a model of
       <a
-      href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>
+      href="http://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>
       whose <code>value_type</code> is an <code>std::pair</code> of
       integer values. These integer values are the source and target
       vertices for the edges, and must fall within the range <code>[0,
@@ -448,7 +448,7 @@ void <a href="#add_edges_sorted_prop">add_edges_sorted</a>(BidirectionalIterator
       to the <a href="#edge-const">edge range constructor</a>, except
       that edge properties are also initialized. The type
       <tt>EdgePropertyIterator</tt> must be a model of the <a
-      href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>
+      href="http://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>
       concept whose <tt>value_type</tt> is convertible to
       <tt>EdgeProperty</tt>. The iterator range <tt>[ep_iter, ep_ter +
         m)</tt> will be used to initialize the properties on the edges
@@ -532,7 +532,7 @@ void <a href="#add_edges_sorted_prop">add_edges_sorted</a>(BidirectionalIterator
       <code>edges_are_sorted</code> can be used to initialize this parameter.
       The <tt>InputIterator</tt> must be a model of
       <a
-      href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>
+      href="http://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>
       whose <code>value_type</code> is an <code>std::pair</code> of
       integer values. These integer values are the source and target
       vertices for the edges, and must fall within the range <code>[0,
@@ -572,7 +572,7 @@ void <a href="#add_edges_sorted_prop">add_edges_sorted</a>(BidirectionalIterator
       to the <a href="#edge-const">edge range constructor</a>, except
       that edge properties are also initialized. The type
       <tt>EdgePropertyIterator</tt> must be a model of the <a
-      href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>
+      href="http://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>
       concept whose <tt>value_type</tt> is convertible to
       <tt>EdgeProperty</tt>. The iterator range <tt>[ep_iter, ep_ter +
         m)</tt> will be used to initialize the properties on the edges
@@ -844,7 +844,7 @@ void add_edges(InputIterator first, InputIterator last, compressed_sparse_row_gr
     <p class="indent">
       Add a range of edges (from <tt>first</tt> to <tt>last</tt>) to the graph.
       The <tt>InputIterator</tt> must be a model of <a
-      href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>
+      href="http://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>
       whose <code>value_type</code> is an <code>std::pair</code> of integer
       values. These integer values are the source and target vertices of the
       new edges.  The edges do not need to be sorted.
@@ -862,7 +862,7 @@ void add_edges(InputIterator first, InputIterator last, EPIter ep_first, EPIter
       corresponding edge properties (from <tt>ep_first</tt> to
       <tt>ep_last</tt>) to the graph.  The <tt>InputIterator</tt> and
       <tt>EPIter</tt> must be models of <a
-      href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>;
+      href="http://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>;
       the <code>value_type</code> of <tt>InputIterator</tt> must be an
       <code>std::pair</code> of integer values, and the <code>value_type</code>
       of <tt>EPIter</tt> must be the edge property type of the graph. The
@@ -880,7 +880,7 @@ void add_edges_sorted(BidirectionalIterator first, BidirectionalIterator last, c
     <p class="indent">
       Add a range of edges (from <tt>first</tt> to <tt>last</tt>) to the graph.
       The <tt>BidirectionalIterator</tt> must be a model of <a
-      href="http://www.sgi.com/tech/stl/BidirectionalIterator.html">BidirectionalIterator</a>
+      href="http://www.boost.org/sgi/stl/BidirectionalIterator.html">BidirectionalIterator</a>
       whose <code>value_type</code> is an <code>std::pair</code> of integer
       values. These integer values are the source and target vertices of the
       new edges.  The edges must be sorted in increasing order by source vertex
@@ -898,7 +898,7 @@ void add_edges_sorted(BidirectionalIterator first, BidirectionalIterator last, E
       Add a range of edges (from <tt>first</tt> to <tt>last</tt>) to the graph.
       The <tt>BidirectionalIterator</tt> and <tt>EPIter</tt> must be models of
       <a
-      href="http://www.sgi.com/tech/stl/BidirectionalIterator.html">BidirectionalIterator</a>.
+      href="http://www.boost.org/sgi/stl/BidirectionalIterator.html">BidirectionalIterator</a>.
       The <code>value_type</code> of the <tt>BidirectionalIterator</tt> must be
       an <code>std::pair</code> of integer
       values. These integer values are the source and target vertices of the
@@ -964,7 +964,7 @@ BGL_FORALL_EDGES(e, g, WebGraph)
 <TD nowrap>Copyright &copy; 2005</TD><TD>
 <A HREF="http://www.boost.org/people/doug_gregor.html">Doug Gregor</A>, Indiana University (<script language="Javascript">address("cs.indiana.edu", "dgregor")</script>)<br>
 Jeremiah Willcock, Indiana University (<script language="Javascript">address("osl.iu.edu", "jewillco")</script>)<br>
-  <A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+  <A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<script language="Javascript">address("osl.iu.edu", "lums")</script>)
 </TD></TR></TABLE>
   </body>

doc/constructing_algorithms.html

@@ -174,7 +174,7 @@ namespace boost {
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/copy_graph.html

@@ -52,7 +52,7 @@ href="./MutableGraph.html">Mutable Graph</a>.
 
 IN: <tt>vertex_copy(VertexCopier vc)</tt>
 <blockquote>
-This is a <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">Binary Function</a> that copies the properties of a vertex in the original graph
+This is a <a href="http://www.boost.org/sgi/stl/BinaryFunction.html">Binary Function</a> that copies the properties of a vertex in the original graph
 into the corresponding vertex in the copy.<br>
 
 <b>Default:</b> <tt>vertex_copier&lt;VertexListGraph, MutableGraph&gt;</tt>
@@ -62,7 +62,7 @@ map from the graph.
 
 IN: <tt>edge_copy(EdgeCopier ec)</tt>
 <blockquote>
-This is a <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">Binary Function</a> that copies the properties of an edge in the original graph
+This is a <a href="http://www.boost.org/sgi/stl/BinaryFunction.html">Binary Function</a> that copies the properties of an edge in the original graph
 into the corresponding edge in the copy.<br>
 
 <b>Default:</b> <tt>edge_copier&lt;VertexListGraph, MutableGraph&gt;</tt>

doc/cuthill_mckee_ordering.html

@@ -151,7 +151,7 @@ For version 1:
 
 <li> <tt>OutputIterator inverse_permutation</tt> &nbsp(OUT) <br> 
   The new vertex ordering. The vertices are written to the <a
-  href="http://www.sgi.com/tech/stl/OutputIterator.html">output
+  href="http://www.boost.org/sgi/stl/OutputIterator.html">output
   iterator</a> in their new order.<br>
   <b>Python</b>: This parameter is unused in Python. The new vertex
   ordering is returned as a Python <tt>list</tt>.
@@ -176,7 +176,7 @@ For version 2:
                                                               href="./VertexListGraph.html">VertexListGraph</a> and <a href="./IncidenceGraph.html">IncidenceGraph</a>.<br>
   <b>Python</b>: The parameter is named <tt>graph</tt>.
 
-<li> <tt><a href="http://www.sgi.com/tech/stl/OutputIterator.html">
+<li> <tt><a href="http://www.boost.org/sgi/stl/OutputIterator.html">
   OutputIterator</a> inverse_permutation</tt> &nbsp(OUT) <br> 
   The new vertex ordering. The vertices are written to the
   output iterator in their new order.<br>
@@ -209,7 +209,7 @@ For version 3:
 
 <li> <tt>OutputIterator inverse_permutation</tt> &nbsp(OUT) <br> 
   The new vertex ordering. The vertices are written to the <a
-  href="http://www.sgi.com/tech/stl/OutputIterator.html">output
+  href="http://www.boost.org/sgi/stl/OutputIterator.html">output
   iterator</a> in their new order.<br>
   <b>Python</b>: This parameter is unused in Python. The new vertex
   ordering is returned as a Python <tt>list</tt>.

doc/dag_shortest_paths.html

@@ -153,7 +153,7 @@ UTIL/OUT: <tt>distance_map(DistanceMap d_map)</tt>
   href="./Monoid.html">Monoid</tt> formed with the <tt>combine</tt>
   function object and the <tt>zero</tt> object for the identity
   element. Also the distance value type must have a <a
-  href="http://www.sgi.com/tech/stl/StrictWeakOrdering.html">
+  href="http://www.boost.org/sgi/stl/StrictWeakOrdering.html">
   StrictWeakOrdering</a> provided by the <tt>compare</tt> function
   object.<br>
   <b>Default:</b> <a
@@ -171,7 +171,7 @@ IN: <tt>distance_compare(CompareFunction cmp)</tt>
   This function is use to compare distances to determine which vertex
   is closer to the source vertex.  The <tt>CompareFunction</tt> type
   must be a model of <a
-  href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary
+  href="http://www.boost.org/sgi/stl/BinaryPredicate.html">Binary
   Predicate</a> and have argument types that match the value type of
   the <tt>DistanceMap</tt> property map.<br>
 
@@ -186,7 +186,7 @@ IN: <tt>distance_combine(CombineFunction cmb)</tt>
 <blockquote>
   This function is used to combine distances to compute the distance
   of a path. The <tt>CombineFunction</tt> type must be a model of <a
-  href="http://www.sgi.com/tech/stl/BinaryFunction.html">Binary
+  href="http://www.boost.org/sgi/stl/BinaryFunction.html">Binary
   Function</a>. The first argument type of the binary function must
   match the value type of the <tt>DistanceMap</tt> property map and
   the second argument type must match the value type of the

doc/depth_first_search.html

@@ -311,7 +311,7 @@ The example in <a href="../example/dfs-example.cpp">
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/dfs_visitor.html

@@ -102,7 +102,7 @@ and <a href="./property_writer.html"><tt>property_writer</tt></a>.
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/dijkstra_shortest_paths.html

@@ -31,7 +31,7 @@ dijkstra_shortest_paths(Graph& g,
 <i>// non-named parameter version</i>
 template &lt;typename Graph, typename <a href="DijkstraVisitor.html">DijkstraVisitor</a>, 
 	  typename PredecessorMap, typename DistanceMap,
-	  typename WeightMap, typename VertexIndexMap, typename <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">CompareFunction</a>, typename <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">CombineFunction</a>, 
+	  typename WeightMap, typename VertexIndexMap, typename <a href="http://www.boost.org/sgi/stl/BinaryPredicate.html">CompareFunction</a>, typename <a href="http://www.boost.org/sgi/stl/BinaryFunction.html">CombineFunction</a>, 
 	  typename DistInf, typename DistZero, typename ColorMap = <i>default</i>&gt;
 void dijkstra_shortest_paths
   (const Graph&amp; g,
@@ -280,7 +280,7 @@ UTIL/OUT: <tt>distance_map(DistanceMap d_map)</tt>
   href="./Monoid.html">Monoid</a> formed with the <tt>combine</tt>
   function object and the <tt>zero</tt> object for the identity
   element. Also the distance value type must have a <a
-  href="http://www.sgi.com/tech/stl/StrictWeakOrdering.html">
+  href="http://www.boost.org/sgi/stl/StrictWeakOrdering.html">
   StrictWeakOrdering</a> provided by the <tt>compare</tt> function
   object.<br>
   <b>Default:</b> <a
@@ -298,7 +298,7 @@ IN: <tt>distance_compare(CompareFunction cmp)</tt>
   This function is use to compare distances to determine which vertex
   is closer to the source vertex.  The <tt>CompareFunction</tt> type
   must be a model of <a
-  href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary
+  href="http://www.boost.org/sgi/stl/BinaryPredicate.html">Binary
   Predicate</a> and have argument types that match the value type of
   the <tt>DistanceMap</tt> property map.<br>
 
@@ -313,14 +313,14 @@ IN: <tt>distance_combine(CombineFunction cmb)</tt>
 <blockquote>
   This function is used to combine distances to compute the distance
   of a path. The <tt>CombineFunction</tt> type must be a model of <a
-  href="http://www.sgi.com/tech/stl/BinaryFunction.html">Binary
+  href="http://www.boost.org/sgi/stl/BinaryFunction.html">Binary
   Function</a>. The first argument type of the binary function must
   match the value type of the <tt>DistanceMap</tt> property map and
   the second argument type must match the value type of the
   <tt>WeightMap</tt> property map.  The result type must be the same
   type as the distance value type.<br>
 
-  <b>Default:</b> <tt>closed_plus&lt;D&gt;</tt> with
+  <b>Default:</b> <tt>std::plus&lt;D&gt;</tt> with
    <tt>D=typename property_traits&lt;DistanceMap&gt;::value_type</tt><br>
 
   <b>Python</b>: Unsupported parameter.

doc/dijkstra_shortest_paths_no_color_map.html

@@ -31,7 +31,7 @@ void dijkstra_shortest_paths_no_color_map
 <i>// non-named parameter version</i>
 template &lt;typename Graph, typename <a href="DijkstraVisitor.html">DijkstraVisitor</a>, 
 	  typename PredecessorMap, typename DistanceMap,
-	  typename WeightMap, typename VertexIndexMap, typename <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">DistanceCompare</a>, typename <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">DistanceWeightCombine</a>, 
+	  typename WeightMap, typename VertexIndexMap, typename <a href="http://www.boost.org/sgi/stl/BinaryPredicate.html">DistanceCompare</a>, typename <a href="http://www.boost.org/sgi/stl/BinaryFunction.html">DistanceWeightCombine</a>, 
 	  typename DistanceInfinity, typename DistanceZero&gt;
 void dijkstra_shortest_paths_no_color_map
   (const Graph&amp; graph,
@@ -44,7 +44,7 @@ void dijkstra_shortest_paths_no_color_map
 <i>// version that does not initialize the property maps</i>
 template &lt;typename Graph, typename <a href="DijkstraVisitor.html">DijkstraVisitor</a>, 
 	  typename PredecessorMap, typename DistanceMap,
-	  typename WeightMap, typename VertexIndexMap, typename <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">DistanceCompare</a>, typename <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">DistanceWeightCombine</a>, 
+	  typename WeightMap, typename VertexIndexMap, typename <a href="http://www.boost.org/sgi/stl/BinaryPredicate.html">DistanceCompare</a>, typename <a href="http://www.boost.org/sgi/stl/BinaryFunction.html">DistanceWeightCombine</a>, 
 	  typename DistanceInfinity, typename DistanceZero&gt;
 void dijkstra_shortest_paths_no_color_map_no_init
   (const Graph&amp; graph,
@@ -243,7 +243,7 @@ UTIL/OUT: <tt>distance_map(DistanceMap distance_map)</tt>
   href="./Monoid.html">Monoid</a> formed with the <tt>distance_weight_combine</tt>
   function object and the <tt>distance_zero</tt> object for the identity
   element. Also the distance value type must have a <a
-  href="http://www.sgi.com/tech/stl/StrictWeakOrdering.html">
+  href="http://www.boost.org/sgi/stl/StrictWeakOrdering.html">
   StrictWeakOrdering</a> provided by the <tt>distance_compare</tt> function
   object.<br>
   <b>Default:</b> <a
@@ -259,7 +259,7 @@ IN: <tt>distance_compare(CompareFunction distance_compare)</tt>
   This function is use to compare distances to determine which vertex
   is closer to the source vertex.  The <tt>DistanceCompareFunction</tt> type
   must be a model of <a
-  href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary
+  href="http://www.boost.org/sgi/stl/BinaryPredicate.html">Binary
   Predicate</a> and have argument types that match the value type of
   the <tt>DistanceMap</tt> property map.<br>
 
@@ -272,7 +272,7 @@ IN: <tt>distance_combine(CombineFunction distance_weight_combine)</tt>
 <blockquote>
   This function is used to combine distances to compute the distance
   of a path. The <tt>DistanceWeightCombineFunction</tt> type must be a model of <a
-  href="http://www.sgi.com/tech/stl/BinaryFunction.html">Binary
+  href="http://www.boost.org/sgi/stl/BinaryFunction.html">Binary
   Function</a>. The first argument type of the binary function must
   match the value type of the <tt>DistanceMap</tt> property map and
   the second argument type must match the value type of the

doc/dijkstra_visitor.html

@@ -116,7 +116,7 @@ and <a href="./property_writer.html"><tt>property_writer</tt></a>.
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/directed_graph.html

@@ -87,7 +87,7 @@ A simple examples of creating a directed_graph is available here <a href="../../
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/distance_recorder.html

@@ -167,7 +167,7 @@ and <a href="./property_writer.html"><tt>property_writer</tt></a>.
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/edge_list.html

@@ -104,7 +104,7 @@ of each vertex in the shortest paths tree.
 </tr>
 
 <TR><TD><TT>EdgeIterator</TT></TD> <TD>Must be model of <a
-href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>
+href="http://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>
 who's <TT>value_type</TT> must be a pair of vertex descriptors.</TD>
 </TR>
 
@@ -212,7 +212,7 @@ Returns the target vertex of edge <TT>e</TT>.
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/edge_predecessor_recorder.html

@@ -182,7 +182,7 @@ and <a href="./property_writer.html"><tt>property_writer</tt></a>.
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/erdos_renyi_generator.html

@@ -144,7 +144,7 @@ int main()
 <TR valign=top>
 <TD nowrap>Copyright &copy; 2005</TD><TD>
 <A HREF="http://www.boost.org/people/doug_gregor.html">Doug Gregor</A>, Indiana University (<script language="Javascript">address("cs.indiana.edu", "dgregor")</script>)<br>
-  <A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+  <A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<script language="Javascript">address("osl.iu.edu", "lums")</script>)
 </TD></TR></TABLE>
 

doc/file_dependency_example.html

@@ -163,7 +163,7 @@ href="./topological_sort.html"><TT>topological_sort()</TT></a>. The
 traditional form of the output for topological sort is a linked-list
 of the sorted vertices.  The BGL algorithm instead puts the sorted
 vertices into any <a
-href="http://www.sgi.com/tech/stl/OutputIterator.html">OutputIterator</a>,
+href="http://www.boost.org/sgi/stl/OutputIterator.html">OutputIterator</a>,
 which allows for much more flexibility.  Here we use the
 <TT>std::front_insert_iterator</TT> to create an output iterator that
 inserts the vertices on the front of a linked list.  Other possible

doc/filtered_graph.html

@@ -129,10 +129,10 @@ E -->
 <TD><TT>EdgePredicate</TT></TD> <TD>A function object that selects
 which edges from the original graph will appear in the filtered
 graph. The function object must model <a
-href="http://www.sgi.com/tech/stl/Predicate.html">Predicate</a>. The
+href="http://www.boost.org/sgi/stl/Predicate.html">Predicate</a>. The
 argument type for the function object must be the edge descriptor type
 of the graph. Also, the predicate must be <a
-href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default Constructible</a> <a href="#1">[1]</a>.</TD>
+href="http://www.boost.org/sgi/stl/DefaultConstructible.html">Default Constructible</a> <a href="#1">[1]</a>.</TD>
 <TD>&nbsp;</TD>
 </TR>
 
@@ -141,10 +141,10 @@ href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default Constructib
 <TD>A function object that selects
 which vertices from the original graph will appear in the filtered
 graph. The function object must model <a
-href="http://www.sgi.com/tech/stl/Predicate.html">Predicate</a>. The
+href="http://www.boost.org/sgi/stl/Predicate.html">Predicate</a>. The
 argument type for the function object must be the vertex descriptor type
 of the graph. Also, the predicate must be <a
-href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default Constructible</a> <a href="#1">[1]</a>.</TD>
+href="http://www.boost.org/sgi/stl/DefaultConstructible.html">Default Constructible</a> <a href="#1">[1]</a>.</TD>
 <TD><TT>keep_all</TT></TD>
 </TR>
 
@@ -501,7 +501,7 @@ This sets the property value for <tt>x</tt> to
 
 <p>
 <a name="1">[1]</a> The reason for requiring <a
-href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default
+href="http://www.boost.org/sgi/stl/DefaultConstructible.html">Default
 Constructible</a> in the <tt>EdgePredicate</tt> and
 <tt>VertexPredicate</tt> types is that these predicates are stored
 by-value (for performance reasons) in the filter iterator adaptor, and
@@ -526,7 +526,7 @@ num_edges(g))</tt>) which is assumed in many of the algorithms.
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/find_odd_cycle.html

@@ -113,7 +113,7 @@ OUT: <tt>OutputIterator result</tt>
 The <tt>find_odd_cycle</tt> function finds an odd-length cycle if the graph is
 not bipartite. The sequence of vertices producing such a cycle is written
 into this iterator. The <tt>OutputIterator</tt> type must be a model of
-<a class="external" href="http://www.sgi.com/tech/stl/OutputIterator.html">
+<a class="external" href="http://www.boost.org/sgi/stl/OutputIterator.html">
 OutputIterator</a>. The graph's vertex descriptor type must be in the set
 of value types of the iterator. The final value is returned by the
 function. If the graph is bipartite (i.e. no odd-length cycle exists), nothing

doc/fruchterman_reingold.html

@@ -130,7 +130,7 @@ computes the attractive force as <code>dist<sup>2</sup>/k</code>.<br>
 IN: <tt>repulsive_force(RepulsiveForce fr)</tt>
 <blockquote>
 Computes the magnitude of the repulsive force between any two
-vertices. The function object <tt>fa</tt> must accept five
+vertices. The function object <tt>fr</tt> must accept five
 parameters: the two vertex descriptors, <tt>k</tt>, the distance between the
 vertices, and the graph. <tt>k</tt> is the square root of the ratio
 of the display area to the number of vertices. <br>

doc/graph_coloring.html

@@ -182,7 +182,7 @@ namespace boost {
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/graph_theory_review.html

@@ -26,7 +26,7 @@ the reader has some previous acquaintance with graph algorithms, this
 chapter should be enough to get started.  If the reader has no
 previous background in graph algorithms we suggest a more thorough
 introduction such as <a
-href="http://toc.lcs.mit.edu/~clr/">Introduction to Algorithms</a>
+href="https://mitpress.mit.edu/algorithms">Introduction to Algorithms</a>
 by Cormen, Leiserson, and Rivest.
 
 <P>

doc/graph_traits.html

@@ -22,7 +22,7 @@ graph_traits&lt;<a href="./Graph.html">Graph</a>&gt;
 </H1>
 
 Just like the <a
-href="http://www.sgi.com/tech/stl/iterator_traits.html">
+href="http://www.boost.org/sgi/stl/iterator_traits.html">
 iterators</a> of STL, graphs have <b>associated types</b>.  As stated
 in the various <a href="./graph_concepts.html">graph concepts</a>, a
 graph has quite a few associated types: <tt>vertex_descriptor</tt>,
@@ -83,8 +83,8 @@ The graph type whose associated types are being accessed.
 <h3>Model of</h3>
 
 <a
-href="http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a> and
-<a href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>
+href="http://www.boost.org/sgi/stl/DefaultConstructible.html">DefaultConstructible</a> and
+<a href="http://www.boost.org/sgi/stl/Assignable.html">Assignable</a>
 
 <h3>Type Requirements</h3>
 
@@ -247,7 +247,7 @@ of vertices in the graph.
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/grid_graph.html

@@ -111,7 +111,7 @@
     <h4>Example</h4>
     <pre class="code">
 <span class="comment">// Define dimension lengths, a 3x3 in this case</span>
-<span class="name">boost</span>::<span class="type">array</span>&lt;<span class="keyword">int</span>, <span class="literal">2</span>&gt; lengths = { { <span class="literal">3</span>, <span class="literal">3</span> } };
+<span class="name">boost</span>::<span class="type">array</span>&lt;<span class="name">std</span>::<span class="type">size_t</span>, <span class="literal">2</span>&gt; lengths = { { <span class="literal">3</span>, <span class="literal">3</span> } };
 
 <span class="comment">// Create a 3x3 two-dimensional, unwrapped grid graph (Figure 1)</span>
 <span class="type">grid_graph</span>&lt;<span class="literal">2</span>&gt; graph(lengths);
@@ -185,7 +185,7 @@ in_edge_at(<span class="name">Traits</span>::<span class="type">vertex_descripto
 <span class="keyword">typedef</span> <span class="type">graph_traits</span>&lt;<span class="name">Graph</span>&gt; <span class="name">Traits</span>;
 
 <span class="comment">// Create a 3x3, unwrapped grid_graph (Figure 3)</span>
-<span class="name">boost</span>::<span class="type">array</span>&lt;<span class="keyword">int</span>, <span class="literal">2</span>&gt; lengths = { { <span class="literal">3</span>, <span class="literal">3</span> } };
+<span class="name">boost</span>::<span class="type">array</span>&lt;<span class="name">std</span>::<span class="type">size_t</span>, <span class="literal">2</span>&gt; lengths = { { <span class="literal">3</span>, <span class="literal">3</span> } };
 <span class="name">Graph</span> graph(lengths);
 
 <span class="comment">// Do a round-trip test of the vertex index functions</span>

doc/grid_graph_export_svg.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/bin/sh
 
 #=======================================================================
 # Copyright 2009 Trustees of Indiana University.
@@ -16,4 +16,4 @@ inkscape --export-png grid_graph_unwrapped.png --export-id g3150 --export-id-onl
 inkscape --export-png grid_graph_wrapped.png grid_graph_unindexed.svg
 
 # Indexed, unwrapped
-inkscape --export-png grid_graph_indexed.png grid_graph_indexed.svg
+inkscape --export-png grid_graph_indexed.png grid_graph_indexed.svg

doc/gursoy_atun_layout.html

@@ -231,7 +231,7 @@ Equivalent to the non-named <tt>vertex_index_map</tt> parameter.<br>
 <TD nowrap>Copyright &copy; 2004 Trustees of Indiana University</TD><TD>
 Jeremiah Willcock, Indiana University (<script language="Javascript">address("osl.iu.edu", "jewillco")</script>)<br>
 <A HREF="http://www.boost.org/people/doug_gregor.html">Doug Gregor</A>, Indiana University (<script language="Javascript">address("cs.indiana.edu", "dgregor")</script>)<br>
-  <A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+  <A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<script language="Javascript">address("osl.iu.edu", "lums")</script>)
 </TD></TR></TABLE>
 

doc/hawick_circuits.html

@@ -25,7 +25,7 @@ self-loops and redundant circuits caused by parallel edges are enumerated too.
 edges are not desired.</p>
 
 <p>The algorithm is described in detail in
-<a href="http://complexity.massey.ac.nz/cstn/013/cstn-013.pdf">http://complexity.massey.ac.nz/cstn/013/cstn-013.pdf</a>.</p>
+<a href="https://www.researchgate.net/publication/221440635_Enumerating_Circuits_and_Loops_in_Graphs_with_Self-Arcs_and_Multiple-Arcs">https://www.researchgate.net/publication/221440635_Enumerating_Circuits_and_Loops_in_Graphs_with_Self-Arcs_and_Multiple-Arcs</a>.</p>
 
 <h3 id="where-defined">Where defined</h3>
 

doc/history.html

@@ -19,16 +19,16 @@
 
 The Boost Graph Library began its life as the Generic Graph Component
 Library (GGCL), a software project at the <a
-href="http://www.lsc.nd.edu">Lab for Scientific Computing (LSC)</a> at
+href="https://web.archive.org/web/20010516042117/http://www.lsc.nd.edu/">Lab for Scientific Computing (LSC)</a> at
 the University of Notre Dame, under the direction of Professor <a
-href="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</a>. The Lab's
+href="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</a>. The Lab's
 research directions include numerical linear algebra, parallel
 computing, and software engineering (including generic programming).
 
 <p>
 Soon after the Standard Template Library was released, work began at
 the LSC to apply generic programming to scientific computing.  The <a
-href="http://www.lsc.nd.edu/research/mtl">Matrix Template Library</a>
+href="https://en.wikipedia.org/wiki/Matrix_Template_Library">Matrix Template Library</a>
 (Jeremy Siek's masters thesis) was one of the first projects. Many of
 the lessons learned during construction of the MTL were applied to the
 design and implementation of the GGCL.
@@ -199,7 +199,7 @@ September 27, 2000.
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/howard_cycle_ratio.html

@@ -97,7 +97,7 @@ The algorithm is due to Howard's iteration policy algorithm, descibed in
 <A HREF="./cochet-terrasson98numerical.pdf">[1]</A>.
 Ali Dasdan, Sandy S. Irani and Rajesh K.Gupta in their paper
 <A HREF="./dasdan-dac99.pdf">Efficient Algorithms for Optimum Cycle Mean and Optimum Cost to Time Ratio
-Problems</A>state that this is the most efficient algorithm to the time being (1999).</P>
+Problems</A> state that this is the most efficient algorithm to the time being (1999).</P>
 
 <p>
 For the convenience, functions <tt>maximum_cycle_mean()</tt> and <tt>minimum_cycle_mean()</tt>
@@ -224,7 +224,7 @@ generates a random graph and computes its maximum cycle ratio.
             <P>Copyright &copy; 2006-2009</P>
         </TD>
         <TD>
-            <P><A HREF="http://www.lsi.upc.edu/~dmitry">Dmitry
+            <P><A HREF="https://web.archive.org/web/20081122083634/http://www.lsi.upc.edu/~dmitry">Dmitry
             Bufistov</A>, Andrey Parfenov</P>
         </TD>
     </TR>

doc/incident.html

@@ -70,7 +70,7 @@ is the target. This function is equivalent to the expression
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/incremental_components.html

@@ -411,7 +411,7 @@ Returns a pair of iterators for the component at <tt>index</tt> where <tt>index<
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/index.html

@@ -297,7 +297,7 @@ iterator and implements an <a href="./EdgeListGraph.html">Edge List Graph</a>.
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/inv_adjacency_iterator.html

@@ -117,7 +117,7 @@ href="../../utility/MultiPassInputIterator.html">Multi-Pass Input Iterator</a>
 
 The inverse adjacency iterator type implements the member functions and
 operators required of the <a
-href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">Random Access Iterator</a>
+href="http://www.boost.org/sgi/stl/RandomAccessIterator.html">Random Access Iterator</a>
 concept, except that the <tt>reference</tt> type is the same as the <tt>value_type</tt>
 so <tt>operator*()</tt> returns by-value. In addition it has the following constructor:
 

doc/isomorphism-impl-v2.w

@@ -25,7 +25,7 @@
 \fi
 
 \ifpdf
-  \newcommand{\stlconcept}[1]{\href{http://www.sgi.com/tech/stl/#1.html}{{\small \textsf{#1}}}}
+  \newcommand{\stlconcept}[1]{\href{https://boost.org/sgi/stl/#1.html}{{\small \textsf{#1}}}}
   \newcommand{\bglconcept}[1]{\href{http://www.boost.org/libs/graph/doc/#1.html}{{\small \textsf{#1}}}}
   \newcommand{\pmconcept}[1]{\href{http://www.boost.org/libs/property_map/#1.html}{{\small \textsf{#1}}}}
   \newcommand{\myhyperref}[2]{\hyperref[#1]{#2}}

doc/isomorphism-impl-v3.w

@@ -31,7 +31,7 @@
 \fi
 
 \ifpdf
-  \newcommand{\stlconcept}[1]{\href{http://www.sgi.com/tech/stl/#1.html}{{\small \textsf{#1}}}}
+  \newcommand{\stlconcept}[1]{\href{https://boost.org/sgi/stl/#1.html}{{\small \textsf{#1}}}}
   \newcommand{\bglconcept}[1]{\href{http://www.boost.org/libs/graph/doc/#1.html}{{\small \textsf{#1}}}}
   \newcommand{\pmconcept}[1]{\href{http://www.boost.org/libs/property_map/#1.html}{{\small \textsf{#1}}}}
   \newcommand{\myhyperref}[2]{\hyperref[#1]{#2}}

doc/isomorphism-impl.w

@@ -25,7 +25,7 @@
 \fi
 
 \ifpdf
-  \newcommand{\stlconcept}[1]{\href{http://www.sgi.com/tech/stl/#1.html}{{\small \textsf{#1}}}}
+  \newcommand{\stlconcept}[1]{\href{https://boost.org/sgi/stl/#1.html}{{\small \textsf{#1}}}}
   \newcommand{\bglconcept}[1]{\href{http://www.boost.org/libs/graph/doc/#1.html}{{\small \textsf{#1}}}}
   \newcommand{\pmconcept}[1]{\href{http://www.boost.org/libs/property_map/#1.html}{{\small \textsf{#1}}}}
   \newcommand{\myhyperref}[2]{\hyperref[#1]{#2}}

doc/isomorphism.html

@@ -111,7 +111,7 @@ This mapping can be used either to speed up the search (as is done by the
 default value, which requires that the degrees of <i>v1</i> and <i>v2</i> are
 equal) or to impose extra conditions on the result.  The
 <tt>VertexInvariant1</tt> and <tt>VertexInvariant2</tt> types must model <a
-href="http://www.sgi.com/tech/stl/UnaryFunction.html">UnaryFunction</a>, with
+href="http://www.boost.org/sgi/stl/UnaryFunction.html">UnaryFunction</a>, with
 the argument type of <tt>vertex_invariant1</tt> being <tt>Graph1</tt>'s vertex
 descriptor type, the argument type of <tt>vertex_invariant2</tt> being
 <tt>Graph2</tt>'s vertex descriptor type, and both functions having integral

doc/johnson_all_pairs_shortest.html

@@ -129,7 +129,7 @@ IN: <tt>distance_compare(CompareFunction cmp)</tt>
   This function is use to compare distances to determine
   which vertex is closer to the source vertex.
   The <tt>CompareFunction</tt> type must be a model of
-  <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary Predicate</a>
+  <a href="http://www.boost.org/sgi/stl/BinaryPredicate.html">Binary Predicate</a>
   and have argument types that
   match the value type of the <tt>WeightMap</tt> property map.<br>
   <b>Default:</b> <tt>std::less&lt;DT&gt;</tt> with
@@ -140,7 +140,7 @@ IN: <tt>distance_combine(CombineFunction cmb)</tt>
 <blockquote>
   This function is used to combine distances to compute the distance
   of a path. The <tt>CombineFunction</tt> type must be a model of <a
-  href="http://www.sgi.com/tech/stl/BinaryFunction.html">Binary
+  href="http://www.boost.org/sgi/stl/BinaryFunction.html">Binary
   Function</a>. Both argument types and the return type of the binary function
   must match the value type of the <tt>WeightMap</tt> property map.  This operation is required to act as the sum operation for the weight type; in particular, it must be the inverse of the binary <tt>-</tt> operator on that type.<br>
   <b>Default:</b> <tt>std::plus&lt;DT&gt;</tt> with

doc/kamada_kawai_spring_layout.html

@@ -314,7 +314,7 @@ an <tt>std::vector</tt> of <tt>Topology::point_difference_type</tt>.<br>
 <td nowrap>Copyright &copy; 2004, 2010 Trustees of Indiana University</td>
 <td><a href="http://www.boost.org/people/doug_gregor.html">Douglas Gregor</a>,
 Indiana University (dgregor -at cs.indiana.edu)<br>
-<a href="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</a>, Indiana
+<a href="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</a>, Indiana
 University (<a href=
 "mailto:lums@osl.iu.edu">lums@osl.iu.edu</a>)</td>
 </tr>

doc/kevin_bacon.html

@@ -130,7 +130,7 @@ pair of actor names. As we add vertices to the graph, we'll need to
 create a map from actor names to their vertices so that later
 appearances of the same actor (on a different edge) can be linked with
 the correct vertex in the graph. The <a
-href="http://www.sgi.com/tech/stl/Map.html"><TT>std::map</TT></a>
+href="http://www.boost.org/sgi/stl/Map.html"><TT>std::map</TT></a>
 can be used to implement this mapping.
 
 <P>

doc/king_ordering.html

@@ -135,7 +135,7 @@ For version 1:
 
 <li> <tt>OutputIterator permutation</tt> &nbsp(OUT) <br> 
   The new vertex ordering. The vertices are written to the <a
-  href="http://www.sgi.com/tech/stl/OutputIterator.html">output
+  href="http://www.boost.org/sgi/stl/OutputIterator.html">output
   iterator</a> in their new order. <br>
   <b>Python</b>: This parameter is unused in Python. The new vertex
   ordering is returned as a Python <tt>list</tt>.
@@ -162,7 +162,7 @@ For version 2:
   href="./VertexListGraph.html">VertexListGraph</a>.<br>
   <b>Python</b>: The name of this parameter is <tt>graph</tt>.
 
-<li> <tt><a href="http://www.sgi.com/tech/stl/OutputIterator.html">
+<li> <tt><a href="http://www.boost.org/sgi/stl/OutputIterator.html">
   OutputIterator</a> permutation</tt> &nbsp(OUT) <br> 
   The new vertex ordering. The vertices are written to the
   output iterator in their new order.<br>
@@ -196,7 +196,7 @@ For version 3:
 
 <li> <tt>OutputIterator permutation</tt> &nbsp(OUT) <br> 
   The new vertex ordering. The vertices are written to the <a
-  href="http://www.sgi.com/tech/stl/OutputIterator.html">output
+  href="http://www.boost.org/sgi/stl/OutputIterator.html">output
   iterator</a> in their new order.<br> 
   <b>Python</b>: This parameter is unused in Python. The new vertex
   ordering is returned as a Python <tt>list</tt>.

doc/known_problems.html

@@ -53,7 +53,7 @@ versions.
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/kruskal_min_spanning_tree.html

@@ -91,7 +91,7 @@ IN: <tt>const Graph&amp; g</tt>
 IN: <tt>OutputIterator spanning_tree_edges</tt>
 <blockquote>
    The edges of the minimum spanning tree are output to this <a
-   href="http://www.sgi.com/tech/stl/OutputIterator.html">Output
+   href="http://www.boost.org/sgi/stl/OutputIterator.html">Output
    Iterator</a>.<br>
 
    <b>Python</b>: This parameter is not used in Python. Instead, a
@@ -108,7 +108,7 @@ The weight or ``length'' of
   each edge in the graph.  The <tt>WeightMap</tt> type must be a model
   of <a href="../../property_map/doc/ReadablePropertyMap.html">Readable
   Property Map</a> and its value type must be <a
-  href="http://www.sgi.com/tech/stl/LessThanComparable.html">Less Than
+  href="http://www.boost.org/sgi/stl/LessThanComparable.html">Less Than
   Comparable</a>. The key type of this map needs to be the graph's
   edge descriptor type.<br>
   <b>Default:</b> <tt>get(edge_weight, g)</tt><br>

doc/leda_conversion.html

@@ -41,7 +41,7 @@ call this free function wrapper approach <I>external adaptation</I>.
 <P>
 One of the more commonly used graph classes is the LEDA parameterized
 <a
-href="http://www.mpi-sb.mpg.de/LEDA/MANUAL/bgraph.html"><TT>GRAPH</TT></a>
+href="https://algorithmic-solutions.info/leda_guide/graphs/param_graph.html"><TT>GRAPH</TT></a>
 class&nbsp;[<A HREF="bibliography.html#mehlhorn99:_leda">22</A>]. In
 this section we will show how to create a BGL interface for this
 class. The first question is which BGL interfaces (or concepts) we
@@ -254,7 +254,7 @@ href="../test/graph.cpp"><TT>test/graph.cpp</TT></a>.
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/maximum_adjacency_search.html

@@ -123,7 +123,7 @@ IN: <tt>const UndirectedGraph&amp; g</tt></p>
   <tt>WeightMap</tt> type must be a model of
   <a href="../../property_map/doc/ReadablePropertyMap.html">Readable
   Property Map</a> and its value type must be <a class="external"
-  href="http://www.sgi.com/tech/stl/LessThanComparable.html">
+  href="http://www.boost.org/sgi/stl/LessThanComparable.html">
   Less Than Comparable</a> and summable. The key type of this map
   needs to be the graph's edge descriptor type.
   <b>Default:</b> <tt>get(edge_weight, g)</tt><br>

doc/maximum_weighted_matching.html

@@ -0,0 +1,163 @@
+<html><head><!--
+     Copyright 2018 Yi Ji
+    
+     Use, modification and distribution is subject to the Boost Software
+     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+    
+      Author: Yi Ji
+  --><title>Boost Graph Library: Maximum Weighted Matching</title></head>
+<body alink="#ff0000" bgcolor="#ffffff" link="#0000ee" text="#000000" vlink="#551a8b">
+<img src="../../../boost.png" alt="C++ Boost" height="86" width="277">
+<br clear="">
+<h1>
+<a name="sec:maximum_weighted_matching">Maximum Weighted Matching</a>
+</h1>
+<pre>
+template &lt;typename Graph, typename MateMap&gt;
+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&gt;
+void brute_force_maximum_weighted_matching(const Graph&amp; g, MateMap mate);
+
+template &lt;typename Graph, typename MateMap, typename VertexIndexMap&gt;
+void brute_force_maximum_weighted_matching(const Graph&amp; g, MateMap mate, VertexIndexMap vm);
+</pre>
+<p>
+<a name="sec:weighted_matching">Before you continue, it is recommended to read
+about <a href="./maximum_matching.html">maximal cardinality matching</a> first. 
+A <i>maximum weighted matching</i> of an edge-weighted graph is a matching
+for which the sum of the weights of the edges is maximum. 
+Two different matchings (edges in the matching are colored blue) in the same graph are illustrated below. 
+The matching on the left is a maximum cardinality matching of size 8 and a maximal
+weighted matching of weight sum 30, meaning that is has maximum size over all matchings in the graph
+and its weight sum can't be increased by adding edges.
+The matching on the right is a maximum weighted matching of size 7 and weight sum 38, meaning that it has maximum
+weight sum over all matchings in the graph.
+
+</a></p><p></p><center>
+<table border="0">
+<tr>
+<td><a name="fig:maximal_weighted_matching"><img src="figs/maximal-weighted-match.png"></a></td>
+<td width="150"></td>
+<td><a name="fig:maximum_weighted_matching"><img src="figs/maximum-weighted-match.png"></a></td>
+</tr>
+</table>
+</center>
+
+<p>
+Both <tt>maximum_weighted_matching</tt> and 
+<tt>brute_force_maximum_weighted_matching</tt> find a
+maximum weighted matching in any undirected graph. The matching is returned in a
+<tt>MateMap</tt>, which is 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>.  
+
+<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.
+
+<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.
+
+<p>
+The outline of the algorithm is as follow:
+
+<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.
+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. 
+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>
+</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.
+
+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.
+
+</p><h3>Where Defined</h3>
+
+<p>
+<a href="../../../boost/graph/maximum_weighted_matching.hpp"><tt>boost/graph/maximum_weighted_matching.hpp</tt></a>
+
+</p><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>
+</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.
+</blockquote>
+
+OUT: <tt>MateMap mate</tt>
+<blockquote>
+Must be a model of <a href="../../property_map/doc/ReadWritePropertyMap.html">ReadWritePropertyMap</a>, mapping
+vertices to vertices. For any vertex v in the graph, <tt>get(mate,v)</tt> will be the vertex that v is matched to, or
+<tt>graph_traits<Graph>::null_vertex()</tt> if v isn't matched.
+</blockquote>
+
+<h3>Complexity</h3>
+
+<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>.
+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><h3>Example</h3>
+
+<p> The file <a href="../example/weighted_matching_example.cpp"><tt>example/weighted_matching_example.cpp</tt></a>
+contains an example.
+
+<br>
+</p><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></tr></tbody></table>
+
+</body></html>

doc/mcgregor_common_subgraphs.html

@@ -56,8 +56,8 @@ template <typename GraphFirst,
           typename GraphSecond,
           typename <a href="../../property_map/doc/ReadablePropertyMap.html">VertexIndexMapFirst</a>,
           typename <a href="../../property_map/doc/ReadablePropertyMap.html">VertexIndexMapSecond</a>,
-          typename <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">EdgeEquivalencePredicate</a>,
-          typename <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">VertexEquivalencePredicate</a>,
+          typename <a href="http://www.boost.org/sgi/stl/BinaryFunction.html">EdgeEquivalencePredicate</a>,
+          typename <a href="http://www.boost.org/sgi/stl/BinaryFunction.html">VertexEquivalencePredicate</a>,
           typename SubGraphCallback&gt;
   void mcgregor_common_subgraphs
   (const GraphFirst&amp; graph1,
@@ -215,7 +215,7 @@ bool operator()(CorrespondenceMapFirstToSecond correspondence_map_1_to_2,
       This function is used to determine if edges
       between <tt>graph1</tt> and <tt>graph2</tt> are equivalent.
       The <tt>EdgeEquivalencePredicate</tt> type must be a model
-      of <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary
+      of <a href="http://www.boost.org/sgi/stl/BinaryPredicate.html">Binary
       Predicate</a> and have argument types
       of <tt>graph_traits&lt;GraphFirst&gt;::edge_descriptor</tt>
       and <tt>graph_traits&lt;GraphSecond&gt;::edge_descriptor</tt>.
@@ -229,7 +229,7 @@ bool operator()(CorrespondenceMapFirstToSecond correspondence_map_1_to_2,
       This function is used to determine if vertices
       between <tt>graph1</tt> and <tt>graph2</tt> are equivalent.
       The <tt>VertexEquivalencePredicate</tt> type must be a model
-      of <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary
+      of <a href="http://www.boost.org/sgi/stl/BinaryPredicate.html">Binary
       Predicate</a> and have argument types
       of <tt>graph_traits&lt;GraphFirst&gt;::vertex_descriptor</tt>
       and <tt>graph_traits&lt;GraphSecond&gt;::vertex_descriptor</tt>.

doc/null_visitor.html

@@ -85,7 +85,7 @@ This does nothing.
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/opposite.html

@@ -70,7 +70,7 @@ assert(u == opposite(e, v, g));
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/plod_generator.html

@@ -131,7 +131,7 @@ int main()
 <TR valign=top>
 <TD nowrap>Copyright &copy; 2005</TD><TD>
 <A HREF="http://www.boost.org/people/doug_gregor.html">Doug Gregor</A>, Indiana University (<script language="Javascript">address("cs.indiana.edu", "dgregor")</script>)<br>
-  <A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+  <A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<script language="Javascript">address("osl.iu.edu", "lums")</script>)
 </TD></TR></TABLE>
 

doc/predecessor_recorder.html

@@ -177,7 +177,7 @@ and <a href="./property_writer.html"><tt>property_writer</tt></a>.
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/prim_minimum_spanning_tree.html

@@ -173,7 +173,7 @@ IN: <tt>weight_map(WeightMap w_map)</tt>
   the graph needs to be usable as the key type for the weight
   map. The value type for the map must be
   the same as the value type of the distance map, and that type must be <a
-    href="http://www.sgi.com/tech/stl/LessThanComparable.html">Less Than
+    href="http://www.boost.org/sgi/stl/LessThanComparable.html">Less Than
       Comparable</a>.<br>
   <b>Default:</b>  <tt>get(edge_weight, g)</tt><br>
   <b>Python</b>: Must be an <tt>edge_double_map</tt> for the graph.<br>

doc/property_map.html

@@ -77,7 +77,7 @@ href="../../property_map/doc/property_map.html">property map</a>.
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/property_put.html

@@ -172,7 +172,7 @@ and <a href="./time_stamper.html"><tt>time_stamper</tt></a>.
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR>

doc/property_writer.html

@@ -87,7 +87,7 @@ to the <tt>value_type</tt> of the <tt>OutputIterator</tt>.
 <TD>
 The iterator type used to write out the property values, which must be
 a model of <a
-href="http://www.sgi.com/tech/stl/OutputIterator.html">OutputIterator</a>.
+href="http://www.boost.org/sgi/stl/OutputIterator.html">OutputIterator</a>.
 </TD>
 <TD>&nbsp;</TD>
 </TR>
@@ -188,7 +188,7 @@ and <a href="./time_stamper.html"><tt>time_stamper</tt></a>.
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/publications.html

@@ -21,7 +21,7 @@
 
 <li><a href="http://www.ddj.com/articles/2000/0009/0009toc.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="http://www.lsc.nd.edu/downloads/research/ggcl/papers/thesis.ps">(ps)</a> <a href="http://www.lsc.nd.edu/downloads/research/ggcl/papers/thesis.pdf">(pdf)</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>
 <li>ISCOPE'99 Sparse Matrix Ordering <a href="./iscope99.pdf">(pdf)</a></li>
 <li><a href="http://www.oonumerics.org/tmpw00/">C++ Template Workshop 2000</a>, Concept Checking</li>
@@ -37,7 +37,7 @@
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/python.html

@@ -36,7 +36,7 @@
     using the BGL in Python.</p>
 
     <p>The Python bindings for the BGL are now part of a <a
-    href="http://www.osl.iu.edu/~dgregor/bgl-python/">separate
+    href="https://web.archive.org/web/20121030074643/http://www.osl.iu.edu:80/~dgregor/bgl-python/">separate
     project</a>. They are no longer available within the Boost
     tree.</p>
     <HR>
@@ -44,7 +44,7 @@
       <TR valign=top>
         <TD nowrap>Copyright &copy; 2005</TD><TD>
           <A HREF="http://www.boost.org/people/doug_gregor.html">Doug Gregor</A>, Indiana University (<script language="Javascript">address("cs.indiana.edu", "dgregor")</script>)<br>
-          <A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+          <A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
           Indiana University (<script language="Javascript">address("osl.iu.edu", "lums")</script>)
     </TD></TR></TABLE>
   </body>

doc/quick_tour.html

@@ -433,7 +433,7 @@ the <tt>Edgelist</tt> and <tt>VertexList</tt></a>). The <tt>directedS</tt> type
 specifies that the graph should be directed (versus undirected). The following
 code shows the specification of the graph type and then the initialization of
 the graph. The edges and weights are passed to the graph constructor in the form
-of iterators (a pointer qualifies as a <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
+of iterators (a pointer qualifies as a <a href="http://www.boost.org/sgi/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
 <p>&nbsp;
 <pre>
   typedef adjacency_list&lt;listS, vecS, directedS, 

doc/r_c_shortest_paths.html

@@ -123,7 +123,7 @@ in:<br>
 Desaulniers, G.; Desrosiers, J.; Solomon, M. (eds.) (2005):<br>
 Column Generation<br>
 Springer, New York, pp. 33&ndash;65<br>
-(available online <a href="http://logistik.bwl.uni-mainz.de/Dateien/or_2004-01.pdf">
+(available online <a href="https://www.researchgate.net/publication/227142556_Shortest_Path_Problems_with_Resource_Constraints">
 here</a>)
 <p>
 
@@ -161,7 +161,7 @@ A type modelling the ResourceContainer concept is used to store the current reso
 
 <p>
 <b>Refinement of</b><br>
-<a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a>, <a href="../../utility/CopyConstructible.html">CopyConstructible</a>, <a href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>, <a href="http://www.sgi.com/tech/stl/LessThanComparable.html">LessThanComparable</a>, <a href="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</a>
+<a href="http://www.boost.org/sgi/stl/DefaultConstructible.html">DefaultConstructible</a>, <a href="../../utility/CopyConstructible.html">CopyConstructible</a>, <a href="http://www.boost.org/sgi/stl/Assignable.html">Assignable</a>, <a href="http://www.boost.org/sgi/stl/LessThanComparable.html">LessThanComparable</a>, <a href="http://www.boost.org/sgi/stl/EqualityComparable.html">EqualityComparable</a>
 </p>
 
 <p>
@@ -262,7 +262,7 @@ Moreover, a reference to a type modelling the ResourceExtensionFunction concept
 </p>
 
 <p>
-Hence, a type modelling the ResourceExtensionFunction concept is likely to be a function or a <a href="http://www.sgi.com/tech/stl/functors.html">function object</a>.
+Hence, a type modelling the ResourceExtensionFunction concept is likely to be a function or a <a href="http://www.boost.org/sgi/stl/functors.html">function object</a>.
 </p>
 
 <p>
@@ -286,7 +286,7 @@ A model of DominanceFunction is used to specify a dominance relation between two
 
 <p>
 <b>Refinement of</b><br>
-<a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">BinaryPredicate</a>
+<a href="http://www.boost.org/sgi/stl/BinaryPredicate.html">BinaryPredicate</a>
 </p>
 
 <p>
@@ -320,7 +320,7 @@ This concept defines the visitor interface for <tt>r_c_shortest_paths</tt>. A us
 
 <p>
 <b>Refinement of</b><br>
-<a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a>, <a href="../../utility/CopyConstructible.html">CopyConstructible</a>
+<a href="http://www.boost.org/sgi/stl/DefaultConstructible.html">DefaultConstructible</a>, <a href="../../utility/CopyConstructible.html">CopyConstructible</a>
 </p>
 
 <p>
@@ -458,11 +458,11 @@ An object specifying the initial resource consumptions at vertex <tt>s</tt>. The
 </blockquote>
 IN: <tt>Resource_Extension_Function&amp; ref</tt>
 <blockquote>
-A <a href="http://www.sgi.com/tech/stl/functors.html">function object</a> or function pointer or function specifying how a label is to be extended along an arc. The type <tt>Resource_Extension_Function</tt> must be a model of the ResourceExtensionFunction concept.
+A <a href="http://www.boost.org/sgi/stl/functors.html">function object</a> or function pointer or function specifying how a label is to be extended along an arc. The type <tt>Resource_Extension_Function</tt> must be a model of the ResourceExtensionFunction concept.
 </blockquote>
 IN: <tt>Dominance_Function&amp; dominance</tt>
 <blockquote>
-A <a href="http://www.sgi.com/tech/stl/functors.html">function object</a> or function pointer or function specifying a dominance relation between two labels. The type <tt>Dominance_Function</tt> must be a model of the DominanceFunction concept.
+A <a href="http://www.boost.org/sgi/stl/functors.html">function object</a> or function pointer or function specifying a dominance relation between two labels. The type <tt>Dominance_Function</tt> must be a model of the DominanceFunction concept.
 </blockquote>
 IN: <tt>Label_Allocator la</tt>
 <blockquote>

doc/random_spanning_tree.html

@@ -151,7 +151,7 @@ IN: <tt>weight_map(WeightMap weight)</tt>
 Indiana University (<A
 HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
 <A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+<A HREF="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
 Indiana University (<A
 HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
 </TD></TR></TABLE>

doc/read_dimacs.html

@@ -65,7 +65,7 @@ int read_dimacs_min_cut(Graph& g,
 </pre>
 
 <p>
-These functions read a BGL graph object from a max-flow or min-cut problem description in extended dimacs format. (see <a href="http://www.avglab.com/andrew/CATS/maxflow_formats.htm"><TT>Goldberg's site</TT></a> for more information). For each edge found in the 
+These functions read a BGL graph object from a max-flow or min-cut problem description in extended dimacs format. (see <a href="https://web.archive.org/web/20120102213028/http://www.avglab.com/andrew/CATS/maxflow_formats.htm"><TT>Goldberg's site</TT></a> for more information). For each edge found in the 
 file an additional reverse_edge is added and set in the reverse_edge map.  For
 max-flow problems, source and sink vertex descriptors are set according to the
 dimacs file.

doc/read_graphviz.html

@@ -55,7 +55,7 @@ vertex property map named <tt class="docutils literal"><span class="pre">node_id
 <dt>Requirements:</dt>
 <dd><ul class="first last simple">
 <li>The type of the graph must model the <a class="reference external" href="MutableGraph.html">Mutable Graph</a> concept.</li>
-<li>The type of the iterator must model the <a class="reference external" href="http://www.sgi.com/tech/stl/InputIterator.html">Input Iterator</a>
+<li>The type of the iterator must model the <a class="reference external" href="http://www.boost.org/sgi/stl/InputIterator.html">Input Iterator</a>
 concept.</li>
 <li>The property map value types must be default-constructible.</li>
 </ul>