Merge pull request #164 from boostorg/develop

merge develop to master for release

.clang-format

@@ -0,0 +1,16 @@
+BasedOnStyle: WebKit
+Standard: Cpp11
+AlignAfterOpenBracket: false
+AlignEscapedNewlinesLeft: true
+AlwaysBreakAfterDefinitionReturnType: None
+BreakBeforeBraces: Allman
+BreakConstructorInitializersBeforeComma: false
+ColumnLimit: 80
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 0
+IndentCaseLabels: false
+SortIncludes: false
+AlignTrailingComments: false
+
+SpacesInAngles: true
+

.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

@@ -0,0 +1,298 @@
+# 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
+
+python: "2.7"
+
+os:
+  - linux
+  - osx
+
+branches:
+  only:
+    - master
+    - develop
+    - /feature\/.*/
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  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
+
+
+script:
+  - |-
+    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

LICENSE

@@ -1,100 +0,0 @@
-COPYRIGHT NOTICE:
-
-Copyright 1997-2000, University of Notre Dame.
-Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek
-
-The Boost Graph Library "Artistic License"
-
-Preamble
-
-The intent of this document is to state the conditions under which a
-Package may be copied, such that the Copyright Holder maintains some
-semblance of artistic control over the development of the package,
-while giving the users of the package the right to use and distribute
-the Package in a more-or-less free fashion, plus the right to make
-reasonable modifications.
-
-Definitions
-
-"Package" refers to the collection of files distributed by the
-Copyright Holder, and derivatives of that collection of files created
-through textual modification.
-
-"Standard Version" refers to such a Package if it has not been
-modified, or has been modified in accordance with the wishes of the
-Copyright Holder as specified below.
-
-"Copyright Holder" is whoever is named in the copyright or copyrights for the package. 
-
-"You" is you, if you're thinking about copying or distributing this Package. 
-
-"Reasonable copying fee" is whatever you can justify on the basis of
-media cost, duplication charges, time of people involved, and so
-on. (You will not be required to justify it to the Copyright Holder,
-but only to the computing community at large as a market that must
-bear the fee.)
-
-"Freely Available" means that no fee is charged for the item itself,
-though there may be fees involved in handling the item. It also means
-that recipients of the item may redistribute it under the same
-conditions they received it.
-
-1. You may make and give away verbatim copies of the source form of
-the Standard Version of this Package without restriction, provided
-that you duplicate all of the original copyright notices and
-associated disclaimers.
-
-2. You may apply bug fixes, portability fixes and other modifications
-derived from the Public Domain or from the Copyright Holder. A Package
-modified in such a way shall still be considered the Standard Version. 
-
-3. You may otherwise modify your copy of this Package in any way,
-provided that you insert a prominent notice in each changed file
-stating how and when you changed that file, and provided that you do
-at least ONE of the following:
-
-  a. place your modifications in the Public Domain or otherwise make
-    them Freely Available, such as by posting said modifications to Usenet
-    or an equivalent medium, or placing the modifications on a major
-    archive site such as uunet.uu.net, or by allowing the Copyright Holder
-    to include your modifications in the Standard Version of the Package.
-  b. use the modified Package only within your corporation or organization. 
-  c. rename any non-standard types and functions so the names do not
-    conflict with Standard Vibrary, which must also be provided, and
-    provide a separate documentation for each non-standard type of function
-    that clearly documents how it differs from the Standard Version.
-  d. make other distribution arrangements with the Copyright Holder. 
-
-4. You may charge a reasonable copying fee for any distribution of this
-Package. You may charge any fee you choose for support of this
-Package. You may not charge a fee for this Package itself. However,
-you may distribute this Package in aggregate with other (possibly
-commercial) programs as part of a larger (possibly commercial)
-software distribution provided that you do not advertise this Package
-as a product of your own. 
-
-5. The name of the Copyright Holder may not be used to endorse or
-promote products derived from this software without specific prior
-written permission.
-
-DISCLAIMER:
-
-LICENSOR MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED.
-By way of example, but not limitation, Licensor MAKES NO
-REPRESENTATIONS OR WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY
-PARTICULAR PURPOSE OR THAT THE USE OF THE LICENSED SOFTWARE COMPONENTS
-OR DOCUMENTATION WILL NOT INFRINGE ANY PATENTS, COPYRIGHTS, TRADEMARKS
-OR OTHER RIGHTS.
-
-The Authors and the University of Notre Dame du Lac shall not be held
-liable for any liability nor for any direct, indirect or consequential
-damages with respect to any claim by LICENSEE or any third party on
-account of or arising from this Agreement or use of this software.
-
-Any disputes arising out of this Agreement or LICENSEE'S use of the
-software at any time shall be resolved by the courts of the state of
-Indiana.  LICENSEE hereby consents to the jurisdiction of the Indiana
-courts and waives the right to challenge the jurisdiction thereof in
-any dispute arising out of this Agreement or Licensee's use of the
-software.
-

README.md

@@ -0,0 +1,44 @@
+Boost Graph Library
+===================
+
+A generic interface for traversing graphs, using C++ templates.
+
+The full documentation is available on [boost.org](http://www.boost.org/doc/libs/release/libs/graph/doc/index.html).
+
+## Support, bugs and feature requests ##
+
+Bugs and feature requests can be reported through the [Trac issue tracker](https://svn.boost.org/trac/boost/query?component=graph&desc=1&order=id)
+(see [open issues](https://svn.boost.org/trac/boost/query?status=!closed&component=graph&desc=1&order=id) and
+[closed issues](https://svn.boost.org/trac/boost/query?status=closed&component=graph&col=id&col=summary&col=status&col=owner&col=type&col=milestone&col=version&desc=1&order=id)). [Here](http://lists.boost.org/Archives/boost/2015/04/221780.php) is why Trac is still in use.
+
+You can submit your changes through a [pull request](https://github.com/boostorg/graph/pulls). One of the maintainers will take a look (remember that it can take some time).
+
+There is no mailing-list specific to Boost Graph, although you can use the general-purpose Boost [mailing-list](http://lists.boost.org/mailman/listinfo.cgi/boost-users) using the tag [graph].
+
+
+## Development ##
+
+Clone the whole boost project, which includes the individual Boost projects as submodules ([see boost+git doc](https://github.com/boostorg/boost/wiki/Getting-Started)): 
+
+    git clone https://github.com/boostorg/boost
+    cd boost
+    git submodule update --init
+
+The Boost Graph Library is located in `libs/graph/`. 
+
+Boost Graph Library is mostly made of headers but also contains some compiled components. Here are the build commands:
+    
+    ./bootstrap.sh            <- compile b2 
+    ./b2 headers              <- just installs headers
+    ./b2                      <- build compiled components
+
+**Note:** The Boost Graph Library cannot currently be built outside of Boost itself.
+
+### Running tests ###
+First, make sure you are in `libs/graph/test`. 
+You can either run all the 300+ tests listed in `Jamfile.v2` or run a single test:
+
+    ../../../b2                        <- run all tests
+    ../../../b2 cycle_canceling_test   <- single test
+
+You can also check the [regression tests reports](http://beta.boost.org/development/tests/develop/developer/graph.html).

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%

build/Jamfile.v2

@@ -0,0 +1,29 @@
+# Copyright (c) 2002 Trustees of Indiana University
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+import mpi ;
+
+project boost/graph
+    : requirements <include>../src
+    : source-location ../src
+    ;
+
+lib boost_graph
+    :
+    read_graphviz_new.cpp
+    graphml.cpp
+    :
+    <library>../../regex/build//boost_regex
+    <link>shared:<define>BOOST_GRAPH_DYN_LINK=1
+    # Without these flags, MSVC 7.1 and 8.0 crash
+    # User reports that VC++ 8.0 does not fail anymore, so that is removed
+    <toolset>msvc-7.1:<cxxflags>-GR-
+    <toolset>sun:<build>no
+    :
+    :
+    ;
+
+boost-install boost_graph ;

doc/AStarHeuristic.html

@@ -0,0 +1,138 @@
+<HTML>
+<!--
+     Copyright (c) 2004 Kris Beevers
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: AStarHeuristic</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1>AStar Heuristic Concept</H1>
+
+This concept defines the interface for the heuristic function of an A*
+search, which is responsible for estimating the remaining cost from
+some vertex to a goal.  The user can create a class that matches this
+interface, and then pass objects of the class into <a
+href="./astar_search.html"><tt>astar_search()</tt></a> to guide the
+order of vertex examination of the search.  The heuristic instance
+must incorporate any necessary information about goal vertices in the
+graph.
+
+For further discussion of the use of heuristics in an A* search, see
+the documentation of <a
+href="./astar_search.html">astar_search()</a>.
+
+<h3>Refinement of</h3>
+
+<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>
+(copying a heuristic should be a lightweight operation).
+
+
+<h3>Notation</h3>
+
+<Table>
+<TR>
+<TD><tt>H</tt></TD>
+<TD>A type that is a model of AStar Heuristic.</TD>
+</TR>
+
+<TR>
+<TD><tt>h</tt></TD>
+<TD>An object of type <tt>H</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>G</tt></TD>
+<TD>A type that is a model of Graph.</TD>
+</TR>
+
+<TR>
+<TD><tt>g</tt></TD>
+<TD>An object of type <tt>G</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>u</tt></TD>
+<TD>An object of type <tt>boost::graph_traits&lt;G&gt;::vertex_descriptor</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>CostType</tt></TD>
+<TD>A type that can be used with the <tt>compare</tt> and
+<tt>combine</tt> functions passed to A*.</TD>
+</TR>
+
+<TR>
+<TD><tt>c</tt></TD>
+<TD>An object of type <tt>CostType</tt>.</TD>
+</TR>
+
+</table>
+
+<h3>Associated Types</h3>
+
+none
+<p>
+
+<h3>Valid Expressions</h3>
+
+<table border>
+<tr>
+<th>Name</th><th>Expression</th><th>Return Type</th><th>Description</th>
+</tr>
+
+<tr>
+<td>Call Heuristic</td>
+<td><tt>CostType c = h(u)</tt></td>
+<td><tt>CostType</tt></td>
+<td>
+Called for the target of every out edge of a vertex being examined.
+</td>
+</tr>
+
+</table>
+
+<h3>Models</h3>
+
+<ul>
+ <li><a href="./astar_heuristic.html"><tt>astar_heuristic</tt></a>
+</ul>
+
+<h3>Concept Checking Class</h3>
+
+<pre>
+  template &lt;class Heuristic, class Graph&gt;
+  struct AStarHeuristicConcept {
+    void constraints()
+    {
+      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept&lt;Heuristic&gt; ));
+      h(u);
+    }
+    Heuristic h;
+    typename graph_traits&lt;Graph&gt;::vertex_descriptor u;
+  };
+</pre>
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2004</TD><TD>
+<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>
+
+</BODY>
+</HTML> 

doc/AStarVisitor.html

@@ -0,0 +1,213 @@
+<HTML>
+<!--
+     Copyright (c) 2004 Kris Beevers
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: AStarVisitor</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1>AStar Visitor Concept</H1>
+
+This concept defines the visitor interface for <a
+href="./astar_search.html"><tt>astar_search()</tt></a>.  Users can
+define a class with the AStar Visitor interface and pass an object of
+the class to <tt>astar_search()</tt>, thereby augmenting the actions
+taken during the graph search.
+
+<h3>Refinement of</h3>
+
+<a href="../../utility/CopyConstructible.html">Copy Constructible</a>
+(copying a visitor should be a lightweight operation).
+
+
+<h3>Notation</h3>
+
+<Table>
+<TR>
+<TD><tt>V</tt></TD>
+<TD>A type that is a model of AStar Visitor.</TD>
+</TR>
+
+<TR>
+<TD><tt>vis</tt></TD>
+<TD>An object of type <tt>V</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>G</tt></TD>
+<TD>A type that is a model of Graph.</TD>
+</TR>
+
+<TR>
+<TD><tt>g</tt></TD>
+<TD>An object of type <tt>const G&amp;</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>e</tt></TD>
+<TD>An object of type <tt>boost::graph_traits&lt;G&gt;::edge_descriptor</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>s,u,v</tt></TD>
+<TD>An object of type <tt>boost::graph_traits&lt;G&gt;::vertex_descriptor</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>d</tt></TD>
+<TD>An object of type <tt>DistanceMap</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>WeightMap</tt></TD>
+<TD>A type that is a model of <a
+href="../../property_map/doc/ReadablePropertyMap.html">Readable Property
+Map</a>.</TD>
+</TR>
+
+<TR>
+<TD><tt>w</tt></TD>
+<TD>An object of type <tt>WeightMap</tt>.</TD>
+</TR>
+
+</table>
+
+<h3>Associated Types</h3>
+
+none
+<p>
+
+<h3>Valid Expressions</h3>
+
+<table border>
+<tr>
+<th>Name</th><th>Expression</th><th>Return Type</th><th>Description</th>
+</tr>
+
+<tr>
+<td>Initialize Vertex</td>
+<td><tt>vis.initialize_vertex(u, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked on each vertex of the graph when it is first
+initialized (i.e., when its property maps are initialized).
+</td>
+</tr>
+
+<tr>
+<td>Discover Vertex</td>
+<td><tt>vis.discover_vertex(u, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked when a vertex is first discovered and is added to the
+OPEN list.
+</td>
+</tr>
+
+<tr>
+<td>Examine Vertex</td>
+<td><tt>vis.examine_vertex(u, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked on a vertex as it is popped from the queue (i.e., it
+has the lowest cost on the OPEN list). This happens immediately before
+<tt>examine_edge()</tt> is invoked on each of the out-edges of vertex
+<tt>u</tt>.
+</td>
+</tr>
+
+<tr>
+<td>Examine Edge</td>
+<td><tt>vis.examine_edge(e, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked on every out-edge of each vertex after it is
+examined.
+</td>
+</tr>
+
+
+<tr>
+<td>Edge Relaxed</td>
+<td><tt>vis.edge_relaxed(e, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+Upon examination, if the following condition holds then the edge is
+relaxed (the distance of its target vertex is reduced) and this method
+is invoked:
+<blockquote>
+<pre>
+tie(u, s) = incident(e, g);
+D d_u = get(d, u), d_v = get(d, s);
+W w_e = get(w, e);
+assert(compare(combine(d_u, w_e), d_s));
+</pre>
+</blockquote>
+</td>
+</tr>
+
+<tr>
+<td>Edge Not Relaxed</td>
+<td><tt>vis.edge_not_relaxed(e, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+Upon examination, if an edge is not relaxed (see above) then this
+method is invoked.
+</td>
+</tr>
+
+<tr>
+<td>Black Target</td>
+<td><tt>vis.black_target(e, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked when a vertex that is on the CLOSED list is
+``rediscovered'' via a more efficient path and is re-added to the
+OPEN list.
+</td>
+</tr>
+
+<tr>
+<td>Finish Vertex</td>
+<td><tt>vis.finish_vertex(u, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked on a vertex when it is added to the CLOSED list. This
+happens after all of its out-edges have been examined.
+</td>
+</tr>
+
+</table>
+
+<h3>Models</h3>
+
+<ul>
+ <li><a href="./astar_visitor.html"><tt>astar_visitor</tt></a>
+</ul>
+
+
+<h3>See also</h3>
+
+<a href="./visitor_concepts.html">Visitor concepts</a>
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2004</TD><TD>
+<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>
+
+</BODY>
+</HTML> 

doc/AddEdgeVisitor.html

@@ -0,0 +1,130 @@
+<html>
+<head>
+<!-- Copyright 2007 Aaron Windsor
+     
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+    
+  -->
+<title>AddEdgeVisitor Concept</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>AddEdgeVisitor Concept</h1>
+
+The AddEdgeVisitor concept exists to allow for some indirection in algorithms
+that modify graphs by adding edges. In such algorithms, it may be convenient
+to perform additional operations (such as updating an edge index map) at 
+points in the algorithm where an edge addition occurs. Replacing calls to
+to <tt>add_edge</tt> with calls to <tt>AddEdgeVisitor::visit_vertex_pair</tt>
+allows for such operations to be defined independently from the algorithm.
+
+<h3>Notation</h3>
+
+<table>
+<tbody>
+
+<tr>
+<td> <tt>Visitor</tt> </td>
+<td> is a type that models the AddEdgeVisitor concept </td>
+</tr>
+
+<tr> 
+<td> <tt>vis</tt> </td>  
+<td> is an object of type Visitor </td>
+</tr>
+
+<tr>
+<td> <tt>Graph</tt> </td>
+<td> is the type of a graph </td>
+</tr>
+
+<tr> 
+<td> <tt>u,v</tt> </td>  
+<td> are objects of type <tt>graph_traits&lt;Graph&gt;::vertex_descriptor</tt>
+</td>
+</tr>
+
+<tr> 
+<td> <tt>e</tt> </td>  
+<td> is an object of type <tt>graph_traits&lt;Graph&gt;::edge_descriptor</tt> 
+</td>
+</tr>
+
+<tr>
+<td> <tt>v</tt> </td>
+<td> is an object of type <tt>graph_traits&lt;Graph&gt;::vertex_descriptor</tt>
+</td>
+
+</tr><tr>
+<td> 
+
+</td></tr></tbody></table>
+
+
+<h3>Associated Types</h3>
+
+None
+
+<h3>Valid Expressions</h3>
+
+<p>
+
+<table border="1">
+
+<tbody><tr><th>Name</th><th>Expression</th><th>Return Type</th>
+<th>Description</th>
+
+</tr><tr> 
+<td> Add an Edge </td>
+<td> <tt>vis.visit_vertex_pair(u, v, g)</tt>  </td>
+<td> <tt>void</tt></td>
+<td> Invoked every time an edge between vertices <tt>u</tt> and <tt>v</tt>
+     should be added to the graph <tt>g</tt>.
+</td></tr>
+
+</tbody></table>
+
+</p><h3>Models</h3>
+
+Two models of this concept are defined in the file 
+<a href="../../../boost/graph/planar_detail/add_edge_visitors.hpp">
+<tt>add_edge_visitors.hpp</tt></a>:
+
+<ul>
+<li><tt>default_add_edge_visitor</tt>: The constructor of this class takes
+no arguments.<tt>visit_vertex_pair(u, v, g)</tt> is just a dispatch to
+<tt>add_edge(u, v, g)</tt>. 
+<li><tt>edge_index_update_visitor</tt>: The constructor of this class takes
+two arguments: the first, an EdgeIndexMap,
+is a <a href="../../property_map/doc/ReadWritePropertyMap.html">
+ReadWritePropertyMap</a> that maps each edge in the associated graph 
+<tt>g</tt> to a distinct integer in the range <tt>[0, num_edges(g))</tt>. 
+The second argument is the number of edges in the underlying graph, which 
+serves as the "next available index" counter within the visitor.
+For example, in the case the graph used has an initialized interior 
+edge index, the <tt>edge_index_update_visitor</tt> constructor should be 
+called with <tt>get(edge_index, g)</tt> as the edge index and 
+<tt>num_edges(g)</tt> as the next available index. When 
+<tt>visit_vertex_pair(u, v, g)</tt> is called, the 
+<tt>edge_index_update_visitor</tt> will add the edge <i>(u,v)</i> to the graph
+and update the edge index for the newly created edge.
+</ul>
+
+<p>
+
+<br>
+</p><hr>
+Copyright © 2007 Aaron Windsor (<a href="mailto:aaron.windsor@gmail.com">
+aaron.windsor@gmail.com</a>) 
+
+</body></html>

doc/AdjacencyGraph.html

@@ -1,20 +1,16 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  Silicon Graphics makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>AdjacencyGraph</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -61,6 +57,12 @@ vertices, whereas in other contexts the edges are also important.
 
 <Table border>
 
+<tr>
+<td><tt>boost::graph_traits&lt;G&gt;::traversal_category</tt><br><br>
+ This tag type must be convertible to <tt>adjacency_graph_tag</tt>.
+</td>
+</tr>
+
 <TR>
 <TD><pre>boost::graph_traits&lt;G&gt;::adjacency_iterator</pre>
 An adjacency iterator for a vertex <i>v</i> provides access to the
@@ -82,8 +84,11 @@ href="../../utility/MultiPassInputIterator.html">MultiPassInputIterator</a>.
 <td><a name="sec:adjacent-vertices"><TT>adjacent_vertices(v,&nbsp;g)</TT></a></TD>
 <TD>
 Returns an iterator-range providing access to the vertices adjacent to
-vertex <TT>v</TT> in graph <TT>g</TT>. <a href="#1">[1]</a><br>
-Return type: <TT>std::pair&lt;adjacency_iterator,&nbsp;adjacency_iterator&gt;</TT>
+vertex <TT>v</TT> in graph <TT>g</TT>.<a
+href="#1">[1]</a>
+
+<br> Return type:
+<TT>std::pair&lt;adjacency_iterator,&nbsp;adjacency_iterator&gt;</TT>
 </TD>
 </TR>
 
@@ -95,19 +100,19 @@ The <TT>adjacent_vertices()</TT> function must return in constant time.
 
 <H3>See Also</H3>
 
-<a href="./graph_concepts.html">Graph concepts</a>
+<a href="./graph_concepts.html">Graph concepts</a>,
+<a href="./adjacency_iterator.html"><tt>adjacency_iterator</tt></a>
 
 <H3>Concept Checking Class</H3>
 
 <PRE>
   template &lt;class G&gt;
-  struct AdjacencyGraph_concept
+  struct AdjacencyGraphConcept
   {
     typedef typename boost::graph_traits&lt;G&gt;::adjacency_iterator
       adjacency_iterator;
     void constraints() {
-      REQUIRE(G, IncidenceGraph);
-      REQUIRE(adjacency_iterator, MultiPassInputIterator);
+      BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept&lt;adjacency_iterator&gt; ));
 
       p = adjacent_vertices(v, g);
       v = *p.first;
@@ -122,6 +127,18 @@ The <TT>adjacent_vertices()</TT> function must return in constant time.
   };
 </PRE>
 
+<h3>Design Rationale</h3>
+
+The AdjacencyGraph concept is somewhat frivolous since <a
+href="./IncidenceGraph.html">IncidenceGraph</a> really covers the same
+functionality (and more).  The AdjacencyGraph concept exists because
+there are situations when <tt>adjacent_vertices()</tt> is more
+convenient to use than <tt>out_edges()</tt>. If you are constructing a
+graph class and do not want to put in the extra work of creating an
+adjacency iterator, have no fear. There is an adaptor class named <a
+href="./adjacency_iterator.html"> <tt>adjacency_iterator</tt></a> that
+you can use to create an adjacency iterator out of an out-edge
+iterator.
 
 <h3>Notes</h3>
 
@@ -142,8 +159,8 @@ experience with graph algorithm implementations.
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>, Univ.of Notre Dame (<A HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
 </TD></TR></TABLE>
 
 </BODY>

doc/AdjacencyMatrix.html

@@ -1,20 +1,16 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  Silicon Graphics makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>AdjacencyMatrix</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -37,6 +33,18 @@ concept.
 
 <a href="./Graph.html">Graph</a>
 
+<H3>Associated Types</H3>
+
+<Table border>
+
+<tr>
+<td><tt>boost::graph_traits&lt;G&gt;::traversal_category</tt><br><br>
+ This tag type must be convertible to <tt>adjacency_matrix_tag</tt>.
+</td>
+</tr>
+
+</table>
+
 <H3>Valid Expressions</H3>
 
 <table border>
@@ -57,9 +65,14 @@ consisting of the edge descriptor if the edge was found.
 </TR>
 </TABLE>
 
+<H3>Complexity guarantees</H3>
+
+The <TT>edge()</TT> function must return in constant time.
+
+
 <H3>Models</H3>
 
-No models of this concept are currently in the Boost Graph Library.
+<a href="./adjacency_matrix.html"><tt>adjacency_matrix</tt></a>
 
 <H3>Concept Checking Class</H3>
 
@@ -82,8 +95,8 @@ No models of this concept are currently in the Boost Graph Library.
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>, Univ.of Notre Dame (<A HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
 </TD></TR></TABLE>
 
 </BODY>

doc/BFSVisitor.html

@@ -1,43 +1,40 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  We make no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>Boost Graph Library: BFSVisitor</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
 
-<H1>BFSVisitor Concept</H1>
+<H1><img src="figs/python.gif" alt="(Python)"/>BFS Visitor Concept</H1>
 
 This concept defines the visitor interface for <a
 href="./breadth_first_search.html"><tt>breadth_first_search()</tt></a>.
-Users can define a class with the BFSVisitor interface and pass and
+Users can define a class with the BFS Visitor interface and pass and
 object of the class to <tt>breadth_first_search()</tt>, thereby
 augmenting the actions taken during the graph search.
 
 <h3>Refinement of</h3>
 
-none
-<p>
+<a href="../../utility/CopyConstructible.html">Copy Constructible</a>
+(copying a visitor should be a lightweight operation).
+
 
 <h3>Notation</h3>
 
 <Table>
 <TR>
 <TD><tt>V</tt></TD>
-<TD>A type that is a model of BFSVisitor.</TD>
+<TD>A type that is a model of BFS Visitor.</TD>
 </TR>
 
 <TR>
@@ -89,16 +86,6 @@ graph search.
 </td>
 </tr>
 
-<tr>
-<td>Start Vertex</td>
-<td><tt>vis.start_vertex(s, g)</tt></td>
-<td><tt>void</tt></td>
-<td>
-This is invoked on the source vertex once before the start of the
-search.
-</td>
-</tr>
-
 <tr>
 <td>Discover Vertex</td>
 <td><tt>vis.discover_vertex(u, g)</tt></td>
@@ -108,6 +95,17 @@ This is invoked when a vertex is encountered for the first time.
 </td>
 </tr>
 
+<tr>
+<td>Examine Vertex</td>
+<td><tt>vis.examine_vertex(u, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked on a vertex as it is popped from the queue. This
+happens immediately before <tt>examine_edge()</tt> is invoked
+on each of the out-edges of vertex <tt>u</tt>.
+</td>
+</tr>
+
 <tr>
 <td>Examine Edge</td>
 <td><tt>vis.examine_edge(e, g)</tt></td>
@@ -128,8 +126,8 @@ form the search tree.</td>
 </tr>
 
 <tr>
-<td>Cycle Edge</td>
-<td><tt>vis.cycle_edge(e, g)</tt></td>
+<td>Non-Tree Edge</td>
+<td><tt>vis.non_tree_edge(e, g)</tt></td>
 <td><tt>void</tt></td>
 <td>
 This is invoked on back or cross edges for directed graphs and cross
@@ -142,7 +140,7 @@ edges for undirected graphs.
 <td><tt>vis.gray_target(e, g)</tt></td>
 <td><tt>void</tt></td>
 <td>
-This is invoked on the subset of cycle edges who's target vertex is
+This is invoked on the subset of non-tree edges whose target vertex is
 colored gray at the time of examination. The color gray indicates
 that the vertex is currently in the queue. 
 </td>
@@ -153,7 +151,7 @@ that the vertex is currently in the queue.
 <td><tt>vis.black_target(e, g)</tt></td>
 <td><tt>void</tt></td>
 <td>
-This is invoked on the subset of cycle edges who's target vertex is
+This is invoked on the subset of non-tree edges whose target vertex is
 colored black at the time of examination. The color black indicates
 that the vertex has been removed from the queue.
 </td>
@@ -166,7 +164,7 @@ that the vertex has been removed from the queue.
 <td>
 This invoked on a vertex after all of its out edges have been added to the
 search tree and all of the adjacent vertices have been discovered
-(but before their out-edges have been examined).
+(but before the out-edges of the adjacent vertices have been examined).
 </td>
 </tr>
 
@@ -178,6 +176,27 @@ search tree and all of the adjacent vertices have been discovered
  <li><a href="./bfs_visitor.html"><tt>bfs_visitor</tt></a>
 </ul>
 
+<a name="python"></a><h3>Python</h3>
+To implement a model of the <tt>BFSVisitor</tt> concept in Python,
+create a new class that derives from the <tt>BFSVisitor</tt> type of
+the graph, which will be
+named <tt><i>GraphType</i>.BFSVisitor</tt>. The events and syntax are
+the same as with visitors in C++. Here is an example for the
+Python <tt>bgl.Graph</tt> graph type:
+
+<pre>
+class count_tree_edges_bfs_visitor(bgl.Graph.BFSVisitor):
+  def __init__(self, name_map):
+    bgl.Graph.BFSVisitor.__init__(self)
+    self.name_map = name_map
+
+  def tree_edge(self, e, g):
+    (u, v) = (g.source(e), g.target(e))
+    print "Tree edge ",
+    print self.name_map[u],
+    print " -> ",
+    print self.name_map[v]
+</pre>
 
 <h3>See also</h3>
 
@@ -187,14 +206,14 @@ search tree and all of the adjacent vertices have been discovered
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~llee1>Lie-Quan Lee</A>, Univ.of Notre Dame (<A HREF="mailto:llee1@lsc.nd.edu">llee1@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~lums>Andrew Lumsdaine</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:lums@lsc.nd.edu">lums@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
 
 </BODY>

doc/BUILD_DOCS.sh

@@ -0,0 +1,22 @@
+#!/bin/sh
+
+# Copyright (C) 2009 The Trustees of Indiana University.
+# Copyright (C) 2010 Daniel Trebbien.
+# 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)
+
+# Authors: Jeremiah Willcock, Daniel Trebbien, Andrew Lumsdaine
+
+for i in read_graphml read_graphviz write_graphml; do
+  rst2html.py -gdt --link-stylesheet --traceback --trim-footnote-reference-space --footnote-references=superscript --stylesheet=../../../rst.css $i.rst > $i.html
+done
+# Also see grid_graph_export_png.sh for figure conversions
+
+# Stoer-Wagner images from Daniel Trebbien
+fdp -s -n -Tgif -ostoer_wagner_imgs/digraph1.gif stoer_wagner_imgs/digraph1.dot
+fdp -s -n -Tgif -ostoer_wagner_imgs/digraph1-min-cut.gif stoer_wagner_imgs/digraph1-min-cut.dot
+fdp -s -n -Tgif -ostoer_wagner_imgs/stoer_wagner-example.gif stoer_wagner_imgs/stoer_wagner-example.dot
+fdp -s -n -Tgif -ostoer_wagner_imgs/stoer_wagner-example-c1.gif stoer_wagner_imgs/stoer_wagner-example-c1.dot
+fdp -s -n -Tgif -ostoer_wagner_imgs/stoer_wagner-example-min-cut.gif stoer_wagner_imgs/stoer_wagner-example-min-cut.dot
+dot -Tgif -ostoer_wagner_imgs/stoer_wagner.cpp.gif stoer_wagner_imgs/stoer_wagner.cpp.dot

doc/BasicMatrix.html

@@ -0,0 +1,103 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>BasicMatrix</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><A NAME="concept:BasicMatrix"></A>
+BasicMatrix
+</H1>
+
+The BasicMatrix concept provides a minimalist interface for
+accessing elements from a 2 dimensional table of values.
+
+
+<H3>Refinement of</H3>
+
+none
+
+<h3>Notation</h3>
+
+<Table>
+<TR>
+<TD>{<tt>M,I,V</tt>}</TD>
+<TD>The matrix, index, and values types that together model the BasicMatrix concept.</TD>
+</TR>
+
+<TR>
+<TD><tt>A</tt></TD>
+<TD>An object of type <tt>M</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>i, j</tt></TD>
+<TD>Objects of type <tt>I</tt>.</TD>
+</TR>
+
+</table>
+
+<H3>Associated Types</H3>
+
+none
+
+<h3>Valid Expressions</h3>
+
+<Table border>
+
+<tr>
+<td><a name="sec:elt-access"><TT>A[i][j]</TT></a></TD>
+<TD>Returns a reference to the element object stored at index <tt>(i,j)</tt><br>
+Return type: <TT>V&amp;</TT> for mutable <tt>A</tt> or <TT>const V&amp;</TT>
+for constant <tt>A</tt>.
+</TD>
+</TR>
+
+</table>
+
+<H3>Complexity guarantees</H3>
+
+Element access is constant time.
+
+<H3>Concept Checking Class</H3>
+
+<pre>
+  template &lt;class M, class I, class V&gt;
+  struct BasicMatrixConcept
+  {
+    void constraints() {
+      V&amp; elt = A[i][j];
+      const_constraints(A);
+      ignore_unused_variable_warning(elt);      
+    }
+    void const_constraints(const M&amp; A) {
+      const V&amp; elt = A[i][j];
+      ignore_unused_variable_warning(elt);      
+    }
+    M A;
+    I i, j;
+  };
+</pre>
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>,
+Indiana University (<A
+HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 

doc/BellmanFordVisitor.html

@@ -1,43 +1,39 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  We make no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
-<Title>Boost Graph Library: BellmanFordVisitor</Title>
+<Title>Boost Graph Library: Bellman Ford Visitor</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
 
-<H1>BellmanFordVisitor Concept</H1>
+<H1><img src="figs/python.gif" alt="(Python)"/>Bellman Ford Visitor Concept</H1>
 
 This concept defines the visitor interface for <a
 href="./bellman_ford_shortest.html"><tt>bellman_ford_shortest_paths()</tt></a>.
-Users can define a class with the BellmanFordVisitor interface and
+Users can define a class with the Bellman Ford Visitor interface and
 pass and object of the class to <tt>bellman_ford_shortest_paths()</tt>,
 thereby augmenting the actions taken during the graph search.
 
 <h3>Refinement of</h3>
 
-none
-<p>
+<a href="../../utility/CopyConstructible.html">Copy Constructible</a>
+(copying a visitor should be a lightweight operation).
 
 <h3>Notation</h3>
 
 <Table>
 <TR>
 <TD><tt>V</tt></TD>
-<TD>A type that is a model of BellmanFordVisitor.</TD>
+<TD>A type that is a model of Bellman Ford Visitor.</TD>
 </TR>
 
 <TR>
@@ -79,16 +75,6 @@ none
 <th>Name</th><th>Expression</th><th>Return Type</th><th>Description</th>
 </tr>
 
-<tr>
-<td>Initialize Vertex</td>
-<td><tt>vis.initialize_vertex(s, g)</tt></td>
-<td><tt>void</tt></td>
-<td>
-This is invoked on every vertex of the graph before the start of the
-graph search.
-</td>
-</tr>
-
 <tr>
 <td>Examine Edge</td>
 <td><tt>vis.examine_edge(e, g)</tt></td>
@@ -130,8 +116,8 @@ this method is invoked.
 <td><tt>vis.edge_minimized(e, g)</tt></td>
 <td><tt>void</tt></td>
 <td>
-After the <tt>num_vertices(g)</tt> iterations through the edge set
-of the graph is complete, one last iteration is made to test whether
+After <tt>num_vertices(g)</tt> iterations through the edge set
+of the graph are completed, one last iteration is made to test whether
 each edge was minimized. If the edge is minimized then this function
 is invoked.
 </td>
@@ -156,19 +142,42 @@ when there is a negative cycle in the graph.
   <li><a href="./bellman_visitor.html"><tt>bellman_visitor</tt></a>
 </ul>
 
+<a name="python"></a>
+<h3>Python</h3>
+
+To implement a model of the <tt>BellmanFordVisitor</tt> concept in Python,
+create a new class that derives from the <tt>BellmanFordVisitor</tt> type of
+the graph, which will be
+named <tt><i>GraphType</i>.BellmanFordVisitor</tt>. The events and syntax are
+the same as with visitors in C++. Here is an example for the
+Python <tt>bgl.Graph</tt> graph type:
+
+<pre>
+class count_tree_edges_bellman_ford_visitor(bgl.Graph.BellmanFordVisitor):
+  def __init__(self, name_map):
+    bgl.Graph.BellmanFordVisitor.__init__(self)
+    self.name_map = name_map
+
+  def edge_relaxed(self, e, g):
+    (u, v) = (g.source(e), g.target(e))
+    print "Relaxed edge ",
+    print self.name_map[u],
+    print " -> ",
+    print self.name_map[v]
+</pre>
 
 <br>
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~llee1>Lie-Quan Lee</A>, Univ.of Notre Dame (<A HREF="mailto:llee1@lsc.nd.edu">llee1@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~lums>Andrew Lumsdaine</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:lums@lsc.nd.edu">lums@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
 
 </BODY>

doc/BidirectionalGraph.html

@@ -1,20 +1,16 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  Silicon Graphics makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>Bidirectional</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -65,6 +61,12 @@ edges incident to the vertex.
 
 <Table border>
 
+<tr>
+<td><tt>boost::graph_traits&lt;G&gt;::traversal_category</tt><br><br>
+ This tag type must be convertible to <tt>bidirectional_graph_tag</tt>.
+</td>
+</tr>
+
 <TR>
 <TD><pre>boost::graph_traits&lt;G&gt;::in_edge_iterator</pre>
 An in-edge iterator for a vertex <i>v</i> provides access to the
@@ -85,7 +87,11 @@ meet the requirements of <a href="../../utility/MultiPassInputIterator.html">Mul
 <TD>
 Returns an iterator-range providing access to the
 in-edges (for directed graphs) or incident edges (for
-undirected graphs) of vertex <TT>v</TT> in graph <TT>g</TT>.<br>
+undirected graphs) of vertex <TT>v</TT> in graph <TT>g</TT>.
+For both directed and undirected graphs, the target of
+an out-edge is required to be vertex <tt>v</tt> and the
+source is required to be a vertex that is adjacent to <tt>v</tt>.
+<br>
 Return type: <TT>std::pair&lt;in_edge_iterator, in_edge_iterator&gt;</TT>
 </TD>
 </TR>
@@ -134,25 +140,30 @@ undirected graphs).
 
 <PRE>
   template &lt;class G&gt;
-  struct BidirectionalGraph_concept
+  struct BidirectionalGraphConcept
   {
     typedef typename boost::graph_traits&lt;G&gt;::in_edge_iterator
       in_edge_iterator;
     void constraints() {
-      REQUIRE(G, IncidenceGraph);
-      REQUIRE(in_edge_iterator, MultiPassInputIterator);
+      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept&lt;in_edge_iterator&gt; ));
 
       p = in_edges(v, g);
+      n = in_degree(v, g);
+      n = degree(v, g);
       e = *p.first;
       const_constraints(g);
     }
     void const_constraints(const G&amp; g) {
       p = in_edges(v, g);
+      n = in_degree(v, g);
+      n = degree(v, g);
       e = *p.first;
     }
     std::pair&lt;in_edge_iterator, in_edge_iterator&gt; p;
     typename boost::graph_traits&lt;G&gt;::vertex_descriptor v;
     typename boost::graph_traits&lt;G&gt;::edge_descriptor e;
+    typename boost::graph_traits&lt;G&gt;::degree_size_type n;
     G g;
   };
 </PRE>
@@ -161,8 +172,8 @@ undirected graphs).
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>, Univ.of Notre Dame (<A HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
 </TD></TR></TABLE>
 
 </BODY>

doc/Buffer.html

@@ -1,21 +1,17 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  Silicon Graphics makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>Buffer</Title>
 </HEAD>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -49,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/Technology/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>
@@ -78,7 +74,7 @@ For a type to model the Buffer concept it must have the following members.
           Precondition: <tt>empty()</tt> is <tt>false</tt>.</td>
      </tr>
 
-<tr> <td> <tt>void size() const</tt> </td>
+<tr> <td> <tt>size_type size() const</tt> </td>
      <td> Returns the number of objects in the Buffer.
           Invariant: <tt>size() >= 0</tt>. </td>
      </tr>
@@ -103,9 +99,8 @@ most linear time complexity in the size of the Generalized Queue.
 <h3>Models</h3>
 
 <UL>
-<LI><a href="http://www.sgi.com/Technology/STL/stack.html"><tt>std::stack</tt></a>
-<LI><a href="../../pri_queue/queue.html"><tt>boost::queue</tt></a>
-<LI><a href="../../pri_queue/p_queue.html"><tt>boost::priority_queue</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>
 
 <p>
@@ -114,8 +109,8 @@ most linear time complexity in the size of the Generalized Queue.
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>, Univ.of Notre Dame and C++ Library & Compiler Group/SGI (<A HREF="mailto:jsiek@engr.sgi.com">jsiek@engr.sgi.com</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University and C++ Library & Compiler Group/SGI (<A HREF="mailto:jsiek@engr.sgi.com">jsiek@engr.sgi.com</A>)
 </TD></TR></TABLE>
 
 </BODY>

doc/ColorValue.html

@@ -1,20 +1,16 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine  2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  We make no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine  2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>Boost Graph Library: ColorValue Concept</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -32,9 +28,9 @@ mark which vertices have been visited.
 <P>
 
 <h3>Refinement of</h3> <a
-href="http://www.sgi.com/Technology/STL/EqualityComparable.html">EqualityComparable</a>
+href="http://www.boost.org/sgi/stl/EqualityComparable.html">EqualityComparable</a>
 and <a
-href="http://www.sgi.com/Technology/STL/DefaultConstructible.html">DefaultConstructible</a>
+href="http://www.boost.org/sgi/stl/DefaultConstructible.html">DefaultConstructible</a>
 
 
 <h3>Notation</h3>
@@ -62,21 +58,21 @@ href="http://www.sgi.com/Technology/STL/DefaultConstructible.html">DefaultConstr
 
 <tr>
 <td>Get Color White </td>
-<TD><TT>white(cv)</TT></TD>
+<TD><TT>color_traits&lt;T&gt;::white()</TT></TD>
 <TD><TT>T</TT></TD>
 <TD>Returns an object that represents the color white.</TD>
 </TR>
 
 <tr>
 <td>Get Color Gray </td>
-<TD><TT>gray(cv)</TT></TD>
+<TD><TT>color_traits&lt;T&gt;::gray()</TT></TD>
 <TD><TT>T</TT></TD>
 <TD>Returns an object that represents the color gray.</TD>
 </TR>
 
 <tr>
 <td>Get Color Black </td>
-<TD><TT>black(cv)</TT></TD>
+<TD><TT>color_traits&lt;T&gt;::black()</TT></TD>
 <TD><TT>T</TT></TD>
 <TD>Returns an object that represents the color black.</TD>
 </TR>
@@ -98,14 +94,14 @@ href="http://www.sgi.com/Technology/STL/DefaultConstructible.html">DefaultConstr
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~llee1>Lie-Quan Lee</A>, Univ.of Notre Dame (<A HREF="mailto:llee1@lsc.nd.edu">llee1@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~lums>Andrew Lumsdaine</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:lums@lsc.nd.edu">lums@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
 
 </BODY>

doc/DFSVisitor.html

@@ -0,0 +1,221 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>DFS Visitor</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><img src="figs/python.gif" alt="(Python)"/>DFS Visitor Concept</H1>
+
+This concept defines the visitor interface for <a
+href="./depth_first_search.html"><tt>depth_first_search()</tt></a>.
+Users can define a class with the DFS Visitor interface and pass an
+object of the class to <tt>depth_first_search()</tt>, thereby
+augmenting the actions taken during the graph search.
+
+<h3>Refinement of</h3>
+
+<a href="../../utility/CopyConstructible.html">Copy Constructible</a>
+(copying a visitor should be a lightweight operation).
+
+<h3>Notation</h3>
+
+<Table>
+<TR>
+<TD><tt>V</tt></TD>
+<TD>A type that is a model of DFS Visitor.</TD>
+</TR>
+
+<TR>
+<TD><tt>vis</tt></TD>
+<TD>An object of type <tt>V</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>G</tt></TD>
+<TD>A type that is a model of Graph.</TD>
+</TR>
+
+<TR>
+<TD><tt>g</tt></TD>
+<TD>An object of type <tt>G</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>e</tt></TD>
+<TD>An object of type <tt>boost::graph_traits&lt;G&gt;::edge_descriptor</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>s,u</tt></TD>
+<TD>An object of type <tt>boost::graph_traits&lt;G&gt;::vertex_descriptor</tt>.</TD>
+</TR>
+
+</table>
+
+<h3>Associated Types</h3>
+
+none
+<p>
+
+<h3>Valid Expressions</h3>
+
+<table border>
+<tr>
+<th>Name</th><th>Expression</th><th>Return Type</th><th>Description</th>
+</tr>
+
+<tr>
+<td>Initialize Vertex</td>
+<td><tt>vis.initialize_vertex(s, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked on every vertex of the graph before the start of the
+graph search.
+</td>
+</tr>
+
+<tr>
+<td>Start Vertex</td>
+<td><tt>vis.start_vertex(s, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked on the source vertex once before the start of the
+search.
+</td>
+</tr>
+
+<tr>
+<td>Discover Vertex</td>
+<td><tt>vis.discover_vertex(u, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked when a vertex is encountered for the first time.
+</td>
+</tr>
+
+<tr>
+<td>Examine Edge</td>
+<td><tt>vis.examine_edge(e, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked on every out-edge of each vertex after it is discovered.
+</td>
+</tr>
+
+
+<tr>
+<td>Tree Edge</td>
+<td><tt>vis.tree_edge(e, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked on each edge as it becomes a member of the edges that
+form the search tree.</td>
+</tr>
+
+<tr>
+<td>Back Edge</td>
+<td><tt>vis.back_edge(e, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked on the back edges in the graph.  For an undirected
+graph there is some ambiguity between tree edges and back edges since
+the edge <i>(u,v)</i> and <i>(v,u)</i> are the same edge, but both the
+<tt>tree_edge()</tt> and <tt>back_edge()</tt> functions will be
+invoked. One way to resolve this ambiguity is to record the tree
+edges, and then disregard the back-edges that are already marked as
+tree edges.  An easy way to record tree edges is to record
+predecessors at the <tt>tree_edge</tt> event point.
+</td>
+</tr>
+
+<tr>
+<td>Forward or Cross Edge</td>
+<td><tt>vis.forward_or_cross_edge(e, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked on forward or cross edges in the graph. In an
+undirected graph this method is never called.
+</td>
+</tr>
+
+<tr>
+<td>Finish Edge</td> 
+<td><tt>vis.finish_edge(e, g)</tt></td> 
+<td><tt>void</tt></td> 
+<td> 
+This is invoked on each non-tree edge as well as on each tree edge after 
+<tt>finish_vertex</tt> has been called on its target vertex.</td> 
+</tr> 
+ 
+<tr> 
+<td>Finish Vertex</td>
+<td><tt>vis.finish_vertex(u, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked on vertex <tt>u</tt> after <tt>finish_vertex</tt> has
+been called for all the vertices in the DFS-tree rooted at vertex
+<tt>u</tt>. If vertex <tt>u</tt> is a leaf in the DFS-tree, then
+the <tt>finish_vertex</tt> function is called on <tt>u</tt> after
+all the out-edges of <tt>u</tt> have been examined.
+</td>
+</tr>
+
+</table>
+
+<h3>Models</h3>
+
+<ul>
+ <li><a href="./dfs_visitor.html"><tt>dfs_visitor</tt></a>
+</ul>
+
+<a name="python"></a>
+<h3>Python</h3>
+
+To implement a model of the <tt>DFSVisitor</tt> concept in Python,
+create a new class that derives from the <tt>DFSVisitor</tt> type of
+the graph, which will be
+named <tt><i>GraphType</i>.DFSVisitor</tt>. The events and syntax are
+the same as with visitors in C++. Here is an example for the
+Python <tt>bgl.Graph</tt> graph type:
+
+<pre>
+class count_tree_edges_dfs_visitor(bgl.Graph.DFSVisitor):
+  def __init__(self, name_map):
+    bgl.Graph.DFSVisitor.__init__(self)
+    self.name_map = name_map
+
+  def tree_edge(self, e, g):
+    (u, v) = (g.source(e), g.target(e))
+    print "Tree edge ",
+    print self.name_map[u],
+    print " -> ",
+    print self.name_map[v]
+</pre>
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
+
+</BODY>
+</HTML> 

doc/DijkstraVisitor.html

@@ -0,0 +1,222 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Dijkstra Visitor</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><img src="figs/python.gif" alt="(Python)"/>Dijkstra Visitor Concept</H1>
+
+This concept defines the visitor interface for <a
+href="./dijkstra_shortest_paths.html"><tt>dijkstra_shortest_paths()</tt></a>
+and related algorithms. The user can create a class that matches this
+interface, and then pass objects of the class into
+<tt>dijkstra_shortest_paths()</tt> to augment the actions taken during
+the search.
+
+<h3>Refinement of</h3>
+
+<a href="../../utility/CopyConstructible.html">Copy Constructible</a>
+(copying a visitor should be a lightweight operation).
+
+
+<h3>Notation</h3>
+
+<Table>
+<TR>
+<TD><tt>V</tt></TD>
+<TD>A type that is a model of Dijkstra Visitor.</TD>
+</TR>
+
+<TR>
+<TD><tt>vis</tt></TD>
+<TD>An object of type <tt>V</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>G</tt></TD>
+<TD>A type that is a model of Graph.</TD>
+</TR>
+
+<TR>
+<TD><tt>g</tt></TD>
+<TD>An object of type <tt>G</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>e</tt></TD>
+<TD>An object of type <tt>boost::graph_traits&lt;G&gt;::edge_descriptor</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>s,u,v</tt></TD>
+<TD>An object of type <tt>boost::graph_traits&lt;G&gt;::vertex_descriptor</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>DistanceMap</tt></TD>
+<TD>A type that is a model of <a href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write Property Map</a>.</TD>
+</TR>
+
+<TR>
+<TD><tt>d</tt></TD>
+<TD>An object of type <tt>DistanceMap</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>WeightMap</tt></TD>
+<TD>A type that is a model of <a href="../../property_map/doc/ReadWritePropertyMap.html">Readable Property Map</a>.</TD>
+</TR>
+
+<TR>
+<TD><tt>w</tt></TD>
+<TD>An object of type <tt>WeightMap</tt>.</TD>
+</TR>
+
+</table>
+
+<h3>Associated Types</h3>
+
+none
+<p>
+
+<h3>Valid Expressions</h3>
+
+<table border>
+<tr>
+<th>Name</th><th>Expression</th><th>Return Type</th><th>Description</th>
+</tr>
+
+<tr>
+<td>Initialize Vertex</td>
+<td><tt>vis.initialize_vertex(u, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked one each vertex of the graph when it is initialized.
+</td>
+</tr>
+
+<tr>
+<td>Examine Vertex</td>
+<td><tt>vis.examine_vertex(u, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked on a vertex as it is popped from the queue. This
+happens immediately before <tt>examine_edge()</tt> is invoked
+on each of the out-edges of vertex <tt>u</tt>.
+</td>
+</tr>
+
+<tr>
+<td>Examine Edge</td>
+<td><tt>vis.examine_edge(e, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked on every out-edge of each vertex after it is discovered.
+</td>
+</tr>
+
+<tr>
+<td>Discover Vertex</td>
+<td><tt>vis.discover_vertex(u, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked when a vertex is encountered for the first time.
+</td>
+</tr>
+
+<tr>
+<td>Edge Relaxed</td>
+<td><tt>vis.edge_relaxed(e, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+Upon examination, if the following condition holds then the edge
+is relaxed (its distance is reduced), and this method is invoked.<br>
+<tt>
+tie(u,v) = incident(e, g);<br>
+D d_u = get(d, u), d_v = get(d, v);<br>
+W w_e = get(w, e);<br>
+assert(compare(combine(d_u, w_e), d_v));<br>
+</tt>
+</td>
+</tr>
+
+<tr>
+<td>Edge Not Relaxed</td>
+<td><tt>vis.edge_not_relaxed(e, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+Upon examination, if the edge is not relaxed (see above) then
+this method is invoked.
+</td>
+</tr>
+
+<tr>
+<td>Finish Vertex</td>
+<td><tt>vis.finish_vertex(u, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This invoked on a vertex after all of its out edges have been added to the
+search tree and all of the adjacent vertices have been discovered
+(but before their out-edges have been examined).
+</td>
+</tr>
+
+</table>
+
+<h3>Models</h3>
+
+<ul>
+ <li><a href="./dijkstra_visitor.html"><tt>dijkstra_visitor</tt></a>
+</ul>
+
+<a name="python"></a>
+<h3>Python</h3>
+
+To implement a model of the <tt>DijkstraVisitor</tt> concept in Python,
+create a new class that derives from the <tt>DijkstraVisitor</tt> type of
+the graph, which will be
+named <tt><i>GraphType</i>.DijkstraVisitor</tt>. The events and syntax are
+the same as with visitors in C++. Here is an example for the
+Python <tt>bgl.Graph</tt> graph type:
+
+<pre>
+class count_tree_edges_dijkstra_visitor(bgl.Graph.DijkstraVisitor):
+  def __init__(self, name_map):
+    bgl.Graph.DijkstraVisitor.__init__(self)
+    self.name_map = name_map
+
+  def edge_relaxed(self, e, g):
+    (u, v) = (g.source(e), g.target(e))
+    print "Relaxed edge ",
+    print self.name_map[u],
+    print " -> ",
+    print self.name_map[v]
+</pre>
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
+
+</BODY>
+</HTML> 

doc/EdgeListGraph.html

@@ -1,20 +1,16 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  Silicon Graphics makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>EdgeListGraph</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -58,6 +54,12 @@ edges in the graph.
 
 <table border>
 
+<tr>
+<td><tt>boost::graph_traits&lt;G&gt;::traversal_category</tt><br><br>
+ This tag type must be convertible to <tt>edge_list_graph_tag</tt>.
+</td>
+</tr>
+
 <tr>
 <td><pre>boost::graph_traits&lt;G&gt;::edge_iterator</pre>
 An edge iterator (obtained via <TT>edges(g)</TT>) provides access to
@@ -139,13 +141,13 @@ must all return in constant time.
 <P>
 <PRE>
   template &lt;class G&gt;
-  struct EdgeListGraph_concept
+  struct EdgeListGraphConcept
   {
     typedef typename boost::graph_traits&lt;G&gt;::edge_iterator 
       edge_iterator;
     void constraints() {
-      REQUIRE(G, Graph);
-      REQUIRE(edge_iterator, MultiPassInputIterator);
+      BOOST_CONCEPT_ASSERT(( GraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept&lt;edge_iterator&gt; ));
 
       p = edges(g);
       E = num_edges(g);
@@ -174,8 +176,8 @@ must all return in constant time.
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>, Univ.of Notre Dame (<A HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
 </TD></TR></TABLE>
 
 </BODY>

doc/EdgeMutableGraph.html

@@ -0,0 +1,108 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek 2001
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Edge Mutable Graph</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+
+<H2><A NAME="concept:EdgeMutableGraph">
+Edge Mutable Graph
+</H2>
+
+The <I>Edge Mutable Graph</I> concept defines the interface for a
+graph that supports the addition and removal of edges.
+
+<H3>Refinement of</H3>
+
+<a href="./Graph.html">Graph</a>
+
+<H3>Associated Types</H3>
+
+No additional associated types.
+
+<h3>Valid Expressions</h3>
+
+<ul>
+
+<li><a name="sec:add_edge"><TT>add_edge(u, v, g)</TT></a> 
+<b>returns</b> <TT>std::pair&lt;edge_descriptor,&nbsp;bool&gt;</TT>
+<br><br>
+
+<b>Semantics:</b> Try to insert the edge <i>(u,v)</i> into the graph,
+returning the inserted edge or a parallel edge and a flag that
+specifies whether an edge was inserted.  This operation must not
+invalidate vertex descriptors or vertex iterators of the graph, though
+it may invalidate edge descriptors or edge iterators.<br>
+
+<b>Preconditions:</b> <i>u</i> and <i>v</i> are vertices in the
+graph. <br>
+
+<b>Postconditions:</b> <i>(u,v)</i> is in the edge set of
+the graph.  The returned edge descriptor will have <i>u</i> in the
+source position and <i>v</i> in the target position. If the graph
+allows parallel edges, then the returned flag is always
+<tt>true</tt>. If the graph does not allow parallel edges, if
+<i>(u,v)</i> was already in the graph then the returned flag is
+<tt>false</tt>. If <i>(u,v)</i> was not in the graph then the returned
+flag is <tt>true</tt>.<br>
+</li><br>
+
+<li><a name="sec:remove_edge_by_pair"><tt>remove_edge(u, v, g)</tt></a>
+<b>returns</b> <tt>void</tt><br><br>
+<b>Semantics:</b> Remove the edge <i>(u,v)</i> from the graph. If the
+graph allows parallel edges this removes all occurrences of <i>(u,v)</i>. <br>
+<b>Precondition:</b> <i>(u,v)</i> is in the edge set of the graph. <br>
+<b>Postcondition:</b> <i>(u,v)</i> is no longer in the edge set of the graph. <br>
+</li><br>
+
+<li>
+<a name="sec:remove_edge"><tt>remove_edge(e, g)</tt></a>
+<b>returns</b> <tt>void</tt><br><br>
+<b>Semantics:</b> Remove the edge <i>e</i> from the graph.<br>
+<b>Precondition:</b> <i>e</i> is an edge in the graph. <br>
+<b>Postcondition:</b> <i>e</i> is no longer in the edge set for <tt>g</tt>. <br>
+</li><br>
+
+<li>
+<a name="sec:clear_vertex"><tt>clear_vertex(u, g)</tt></a>
+<b>returns</b> <tt>void</tt><br><br>
+<b>Semantics:</b> Remove all edges to and from vertex <i>u</i> from the graph. <br>
+<b>Precondition:</b> <i>u</i> is a valid vertex descriptor of
+<tt>g</tt>. <br> <b>Postconditions:</b> <i>u</i> does not appear as a
+source or target of any edge in <tt>g</tt>.
+</li>
+
+</ul>
+
+
+<H3>Complexity guarantees</H3>
+
+<P>
+UNDER CONSTRUCTION
+
+<H3>See Also</H3>
+
+<a href="./graph_concepts.html">Graph concepts</a>
+
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 

doc/EventVisitor.html

@@ -1,20 +1,16 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  We make no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>Boost Graph Library: EventVisitor</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -60,8 +56,8 @@ namespace boost {
 
 <h3>Refinement of</h3>
 
-none
-<p>
+<a href="../../utility/CopyConstructible.html">Copy Constructible</a>
+(copying a visitor should be a lightweight operation).
 
 <h3>Notation</h3>
 
@@ -151,14 +147,14 @@ either a vertex or edge descriptor of the graph.
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~llee1>Lie-Quan Lee</A>, Univ.of Notre Dame (<A HREF="mailto:llee1@lsc.nd.edu">llee1@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~lums>Andrew Lumsdaine</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:lums@lsc.nd.edu">lums@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
 
 </BODY>

doc/EventVisitorList.html

@@ -1,20 +1,16 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  We make no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>Boost Graph Library: EventVisitorList</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -23,7 +19,7 @@
 
 An EventVisitorList is either an <a
 href="./EventVisitor.html">EventVisitor</a>, or a list of
-EventVisitor's combined using <tt>std::pair</tt>. Each graph algorithm
+EventVisitors combined using <tt>std::pair</tt>. Each graph algorithm
 defines visitor adaptors that convert an EventVisitorList into the
 particular kind of visitor needed by the algorithm.
 
@@ -38,7 +34,7 @@ href="./graph_theory_review.html#sec:dfs-algorithm">depth-first
 search</a>. We can use the BGL algorithm <a
 href="./depth_first_search.html"><tt>depth_first_search()</tt></a> and
 two event visitors to accomplish this. The complete source code for
-the following example is in <a href="../examples/dfs_parenthesis.cpp">
+the following example is in <a href="../example/dfs_parenthesis.cpp">
 <tt>examples/dfs_parenthesis.cpp</tt></a>. First we define the two
 event visitors. We use <tt>on_discover_vertex</tt> and
 <tt>on_finish_vertex</tt> as the event points, selected from the list
@@ -95,7 +91,7 @@ Now we can pass the resulting visitor object into
                      color.begin());
 </pre>
 
-For creating a list of more than two event visitors, nest calls to
+For creating a list of more than two event visitors, you can nest calls to
 <tt>std::make_pair</tt> in the following way:
 
 <pre>
@@ -117,14 +113,14 @@ std::make_pair(<i>visitor1</i>,
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~llee1>Lie-Quan Lee</A>, Univ.of Notre Dame (<A HREF="mailto:llee1@lsc.nd.edu">llee1@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~lums>Andrew Lumsdaine</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:lums@lsc.nd.edu">lums@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
 
 </BODY>

doc/Graph.html

@@ -0,0 +1,148 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Graph</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H2><A NAME="concept:Graph"></A>
+Graph
+</H2>
+
+<P>
+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.boost.org/sgi/stl/Assignable.html">Assignable</a>,
+so algorithms should pass graph objects by reference.
+
+<P>
+
+<h3>Notation</h3>
+
+<Table>
+<TR>
+<TD><tt>G</tt></TD>
+<TD>A type that is a model of Graph.</TD>
+</TR>
+
+<TR>
+<TD><tt>g</tt></TD>
+<TD>An object of type <tt>G</tt>.</TD>
+</TR>
+</table>
+
+<H3>Associated Types</H3>
+
+<table border>
+<tr>
+<td><pre>boost::graph_traits&lt;G&gt;::vertex_descriptor</pre>
+A vertex descriptor corresponds to a unique vertex in an abstract
+graph instance. A vertex descriptor must be
+<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>
+
+<tr>
+<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.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>
+
+<tr>
+<td><pre>boost::graph_traits&lt;G&gt;::directed_category</pre>
+This type shall be convertible to <TT>directed_tag</TT> or <TT>undirected_tag</TT>.
+</td>
+</tr>
+
+<tr>
+<td><pre>boost::graph_traits&lt;G&gt;::edge_parallel_category</pre>
+This describes whether the graph class allows the insertion of
+parallel edges (edges with the same source and target). The two tags
+are <TT>allow_parallel_edge_tag</TT> and <TT>disallow_parallel_edge_tag</TT>.
+</td>
+</tr>
+
+<tr>
+<td><pre>boost::graph_traits&lt;G&gt;::traversal_category</pre>
+This describes the ways in which the vertices and edges of the
+graph can be visited. The choices are <TT>incidence_graph_tag</TT>,
+<TT>adjacency_graph_tag</TT>, <TT>bidirectional_graph_tag</TT>, 
+<TT>vertex_list_graph_tag</TT>, <TT>edge_list_graph_tag</TT>, and 
+<TT>adjacency_matrix_tag</TT>.
+</td>
+</tr>
+
+</table>
+
+<H3>Valid Expressions</H3>
+
+<table border>
+
+<tr>
+<td><pre>boost::graph_traits&lt;G&gt;::null_vertex()</pre></td></TD>
+<td>
+Returns a special <tt>boost::graph_traits&lt;G&gt;::vertex_descriptor</tt> object which does not refer to
+any vertex of graph object which type is <tt>G</tt>.
+<td>
+</tr>
+</table>
+
+
+
+<H3>Concept Checking Class</H3>
+
+<PRE>
+  template &lt;class G&gt;
+  struct GraphConcept
+  {
+    typedef typename boost::graph_traits&lt;G&gt;::vertex_descriptor vertex_descriptor;
+    typedef typename boost::graph_traits&lt;G&gt;::edge_descriptor edge_descriptor;
+    typedef typename boost::graph_traits&lt;G&gt;::directed_category directed_category;
+    typedef typename boost::graph_traits&lt;G&gt;::edge_parallel_category edge_parallel_category;
+    typedef typename boost::graph_traits&lt;G&gt;::traversal_category traversal_category;
+
+    void constraints() {
+      BOOST_CONCEPT_ASSERT(( DefaultConstructibleConcept&lt;vertex_descriptor&gt; ));
+      BOOST_CONCEPT_ASSERT(( EqualityComparableConcept&lt;vertex_descriptor&gt; ));
+      BOOST_CONCEPT_ASSERT(( AssignableConcept&lt;vertex_descriptor&gt; ));
+      BOOST_CONCEPT_ASSERT(( DefaultConstructibleConcept&lt;edge_descriptor&gt; ));
+      BOOST_CONCEPT_ASSERT(( EqualityComparableConcept&lt;edge_descriptor&gt; ));
+      BOOST_CONCEPT_ASSERT(( AssignableConcept&lt;edge_descriptor&gt; ));
+    }
+    G g;
+  };
+</PRE>
+
+<H3>See Also</H3>
+
+<a href="./graph_concepts.html">Graph concepts</a>
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 

doc/IncidenceGraph.html

@@ -1,20 +1,16 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  We make no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>IncidenceGraph</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -50,8 +46,8 @@ efficient access to the out-edges of each vertex in the graph.
 </TR>
 
 <TR>
-<TD><tt>v</tt></TD>
-<TD>An object of type <tt>boost::graph_traits&lt;G&gt;::vertex_descriptor</tt>.</TD>
+<TD><tt>u, v</tt></TD>
+<TD>Are objects of type <tt>boost::graph_traits&lt;G&gt;::vertex_descriptor</tt>.</TD>
 </TR>
 
 </table>
@@ -60,6 +56,13 @@ efficient access to the out-edges of each vertex in the graph.
 
 <Table border>
 
+<tr>
+<td><tt>boost::graph_traits&lt;G&gt;::traversal_category</tt><br><br>
+ This tag type must be convertible to <tt>incidence_graph_tag</tt>.
+</td>
+</tr>
+
+
 <TR>
 <TD>
 <pre>boost::graph_traits&lt;G&gt;::out_edge_iterator</pre>
@@ -73,7 +76,7 @@ href="../../utility/MultiPassInputIterator.html">MultiPassInputIterator</a>.
 
 <TR>
 <TD><pre>boost::graph_traits&lt;G&gt;::degree_size_type</pre>
-The unsigned intergral type used for representing the number
+The unsigned integral type used for representing the number
 out-edges or incident edges of a vertex.
 </TD>
 </TR>
@@ -85,7 +88,7 @@ out-edges or incident edges of a vertex.
 <Table border>
 
 <tr>
-<td><a name="sec:source"><TT>source(e, g)</TT></a></TD>
+<td><a name="sec:source"><TT>source(e,&nbsp;g)</TT></a></TD>
 <TD>Returns the vertex descriptor for <i>u</i> of the edge <i>(u,v)</i> represented by <TT>e</TT>.<br>
 Return type: <TT>vertex_descriptor</TT>
 </TD>
@@ -93,24 +96,29 @@ Return type: <TT>vertex_descriptor</TT>
 
 
 <tr>
-<td><a name="sec:target"><TT>target(e, g)</TT></a></TD>
+<td><a name="sec:target"><TT>target(e,&nbsp;g)</TT></a></TD>
 <TD>Returns the vertex descriptor for <i>v</i> of the edge <i>(u,v)</i> represented by <TT>e</TT>.<br>
 Return type: <TT>vertex_descriptor</TT>
 </td></tr>
 
 <tr>
-<td><a name="sec:out-edges"><TT>out_edges(v, g)</TT></a></TD>
-<TD>Returns an iterator-range providing access to the
-out-edges (for directed graphs) or incident edges (for
-undirected graphs) of vertex <TT>v</TT> in graph <TT>g</TT>.<br>
+<td><a name="sec:out-edges"><TT>out_edges(u,&nbsp;g)</TT></a></TD>
+<TD>Returns an iterator-range providing access to the out-edges (for
+directed graphs) or incident edges (for undirected graphs) of vertex
+<TT>u</TT> in graph <TT>g</TT>.  The source vertex of an edge obtained
+via an out edge iterator is guaranteed (for both directed and
+undirected graphs) to be the vertex <tt>u</tt> used in the call to
+<tt>out_edges(u, g)</tt> and the target vertex must be a vertex
+adjacent to <tt>u</tt>.<a href="#1">[1]</a>
+<br>
 Return type: <TT>std::pair&lt;out_edge_iterator, out_edge_iterator&gt;</TT>
 </TD>
 </tr>
 
 <tr>
-<TD><TT>out_degree(v, g)</TT></TD>
+<TD><TT>out_degree(u,&nbsp;g)</TT></TD>
 <TD>Returns the number of out-edges (for directed graphs) or the
-number of incident edges (for undirected graphs) of vertex <TT>v</TT>
+number of incident edges (for undirected graphs) of vertex <TT>u</TT>
 in graph <TT>g</TT>.<br>
 Return type: <TT>degree_size_type</TT>
 </TD>
@@ -133,24 +141,37 @@ function must be linear in the number of out-edges.
 
 <a href="./graph_concepts.html">Graph concepts</a>
 
+<H3>Notes</H3>
+
+<a name="1">[1]</a> For undirected graphs, the edge <tt>(u,v)</tt> is
+the same as edge <tt>(v,u)</tt>, so without some extra guarantee an
+implementation would be free use any ordering for the pair of vertices
+in an out-edge. For example, if you call <tt>out_edges(u, g)</tt>, and
+<tt>v</tt> is one of the vertices adjacent to <tt>u</tt>, then the
+implementation would be free to return <tt>(v,u)</tt> as an out-edge
+which would be non-intuitive and cause trouble for algorithms.
+Therefore, the extra requirement is added that the out-edge connecting
+<tt>u</tt> and <tt>v</tt> must be given as <tt>(u,v)</tt> and not
+<tt>(v,u)</tt>.
+
 <H3>Concept Checking Class</H3>
 
 <PRE>
   template &lt;class G&gt;
-  struct IncidenceGraph_concept
+  struct IncidenceGraphConcept
   {
     typedef typename boost::graph_traits&lt;G&gt;::out_edge_iterator out_edge_iterator;
     void constraints() {
-      REQUIRE(G, Graph);
-      REQUIRE(out_edge_iterator, MultiPassInputIterator);
+      BOOST_CONCEPT_ASSERT(( GraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept&lt;out_edge_iterator&gt; ));
 
-      p = out_edges(v, g);
+      p = out_edges(u, g);
       e = *p.first;
       u = source(e, g);
       v = target(e, g);
     }
     void const_constraints(const G&amp; g) {
-      p = out_edges(v, g);
+      p = out_edges(u, g);
       e = *p.first;
       u = source(e, g);
       v = target(e, g);
@@ -167,14 +188,14 @@ function must be linear in the number of out-edges.
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~llee1>Lie-Quan Lee</A>, Univ.of Notre Dame (<A HREF="mailto:llee1@lsc.nd.edu">llee1@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~lums>Andrew Lumsdaine</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:lums@lsc.nd.edu">lums@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
 
 </BODY>

doc/IteratorConstructibleGraph.html

@@ -0,0 +1,161 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>IteratorConstructibleGraph</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><A NAME="concept:IteratorConstructibleGraph"></A>
+IteratorConstructibleGraph
+</H1>
+
+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.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 <
+|V|</i>.  The edge iterator's value type should be
+<tt>std::pair&lt;T,T&gt;</tt> (or at least be a structure that has
+members <tt>first</tt> and <tt>second</tt>) and the value type
+<tt>T</tt> of the pair must be convertible to the
+<tt>vertices_size_type</tt> of the graph (an integer).
+
+There are two valid expressions required by this concept, both of
+which are constructors. The first creates a graph object from a
+first/last iterator range. The second constructor also takes a
+first/last iterator range and in addition requires the number of
+vertices and number of edges. For some graph and edge iterator types
+the second constructor can be more efficient than the first.
+
+<h3>Example</h3>
+
+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.boost.org/sgi/stl/InputIterator.html">InputIterator</a>
+and can therefore be used to construct a graph.
+
+<pre>
+  typedef ... IteratorConstructibleGraph;
+  typedef boost::graph_traits<IteratorConstructibleGraph> Traits;
+
+  typedef std::pair<Traits::vertices_size_type, 
+    Traits::vertices_size_type> Edge;
+  Edge edge_array[] =
+    { Edge(0,1), Edge(0,2), Edge(0,3), Edge(0,4), Edge(0,5),
+      Edge(1, 2), Edge(1,5), Edge(1,3),
+      Edge(2, 4), Edge(2,5),
+      Edge(3, 2), 
+      Edge(4, 3), Edge(4,1),
+      Edge(5, 4) };
+  Edge* first = edge_array,
+    last = edge_array + sizeof(edge_array)/sizeof(Edge);
+
+  IteratorConstructibleGraph G1(first, last);
+  // do something with G1 ...
+  
+  Traits::vertices_size_type size_V = 6;
+  Traits::edges_size_type size_E = sizeof(edge_array)/sizeof(Edge);
+  IteratorConstructibleGraph G2(first, last, size_V, size_E);
+  // do something with G2 ...
+</pre>
+
+<h3>Refinement of</h3>
+
+<a href="Graph.html">Graph</a>
+
+<h3>Notation</h3>
+
+<Table>
+<tr>
+<td><tt>G</tt></td>
+<td>is a graph type that models IteratorConstructibleGraph.</td>
+<tr>
+
+<tr>
+<td><tt>g</tt></td>
+<td>is an object of type <tt>G</tt>.</td>
+</tr>
+
+<tr>
+<td><tt>first, last</tt></td>
+<td>are edge iterators (see above).</td>
+</tr>
+
+<tr>
+<td><tt>Tr</tt></td>
+<td>is an object of type <tt>graph_traits&lt;G&gt;</tt>.</td>
+</tr>
+
+<tr>
+<td><tt>n_vertices</tt></td>
+<td>is an object of type <tt>Tr::vertices_size_type</tt>.</td>
+</tr>
+
+<tr>
+<td><tt>n_edges</tt></td>
+<td>is an object of type <tt>Tr::edges_size_type</tt>.</td>
+</tr>
+
+</Table>
+
+
+<h3>Valid Expressions</h3>
+
+<Table border>
+
+<tr>
+<td>
+<pre>G g(first, last);</pre>
+Construct graph object <tt>g</tt> given an edge range <tt>[first,last)</tt>.
+</td>
+<tr>
+
+<tr>
+<td>
+<pre>G g(first, last, n_vertices, n_edges);</pre>
+Construct graph object <tt>g</tt> given an edge range
+<tt>[first,last)</tt>, the number of vertices, and the number of
+edges.  Sometimes this constructor is more efficient than the
+constructor lacking the graph size information.
+</td>
+</tr>
+
+</Table>
+
+
+<!--
+<H3>Concept Checking Class</H3>
+
+<PRE>
+</PRE>
+-->
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
+
+</BODY>
+</HTML> 

doc/KeyedUpdatableQueue.html

@@ -0,0 +1,99 @@
+<!DOCTYPE html>
+<!--
+            Copyright Daniel Trebbien 2010.
+ Distributed under the Boost Software License, Version 1.0.
+   (See accompanying file LICENSE_1_0.txt or the copy at
+         http://www.boost.org/LICENSE_1_0.txt)
+-->
+<html>
+<head>
+<title>KeyedUpdatableQueue</title>
+</head>
+<body> 
+<img src="../../../boost.png"  alt="C++ Boost">
+
+<h2><a name="concept:KeyedUpdatableQueue">KeyedUpdatableQueue</a></h2>
+
+<p>A <i>KeyedUpdatableQueue</i> is a refinement of the <a href="./UpdatableQueue.html">UpdatableQueue</a> concept.
+It requires that models order the contained values by their <i>keys</i>, to which
+values are mapped via a read/write key map.
+
+<h3>Notation</h3>
+
+<table>
+<tr> <td> <tt>Q</tt> </td>  <td> is a type that models KeyedUpdatableQueue.       </td></tr>
+<tr> <td> <tt>T</tt> </td>  <td> is the value type of <tt>Q</tt>. </td></tr>
+</table>
+
+
+<h3>Members</h3>
+
+For a type to model the KeyedUpdatableQueue concept it must have the following members 
+in addition to the members that are required of types that model <a href="./UpdatableQueue.html">UpdatableQueue</a>:
+
+<p>
+
+<table border="1">
+
+<tr> <td><b>Member</b></td> <td><b>Description</b></td> </tr>
+
+<tr> <td> <tt>key_type</tt> </td>
+     <td> The type of keys that are associated with values </td>
+     </tr>
+
+<tr> <td> <tt>key_map</tt> </td>
+     <td> The key property map type. This type must model <a href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write Property Map</a>. </td>
+     </tr>
+
+<tr> <td> <tt>key_map keys() const</tt> </td>
+     <td> Returns the key map </td>
+     </tr>
+
+</table>
+
+<h3>Concept Checking Class</h3>
+
+<p><a href="../../../boost/graph/buffer_concepts.hpp"><tt>boost/graph/buffer_concepts.hpp</tt></a>
+
+<pre>
+  template &lt;class Q&gt;
+  struct KeyedUpdatableQueueConcept
+  {
+    typedef typename Q::key_type key_type;
+    typedef typename Q::key_map key_map;
+    
+    void constraints() {
+      BOOST_CONCEPT_ASSERT(( UpdatableQueue&lt;Q&gt; ));
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMap&lt; key_map, typename Buffer&lt;Q&gt;::value_type &gt; ));
+    }
+    
+    void const_constraints(const Q&amp; cq) {
+      km = cq.keys();
+      k = get(km, g_ct);
+    }
+    
+    static const typename Buffer&lt;Q&gt;::value_type g_ct;
+    key_type k;
+    key_map km;
+    Q q;
+  };
+</pre>
+
+<h3>Models</h3>
+
+<ul>
+<li><tt>boost::d_ary_heap_indirect</tt></a>
+</ul>
+
+<br>
+<hr>
+<table>
+<tr>
+<td>Copyright&nbsp;&copy;&nbsp;2010</td>
+<td>Daniel Trebbien (<a href="mailto:dtrebbien@gmail.com">dtrebbien@gmail.com</a>)
+</td>
+</tr>
+</table>
+
+</body>
+</html>

doc/Makefile

@@ -0,0 +1,101 @@
+# Copyright (c) 2002 Trustees of Indiana University
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+DVIPS		= dvips
+
+LATEX		= latex
+LATEXOUT	= dvi
+RESULT		= ps
+
+LATEX		= pdflatex
+LATEXOUT	= pdf
+RESULT		= pdf
+
+.SUFFIXES: .tex .dvi .ps .pdf .c .lg .eps .fig .gif .dot .w .cpp .o .exe
+
+.tex.$(LATEXOUT):
+	@ if test ! -f $*.ind; then echo "" > $*.ind; fi
+	@ $(LATEX) $*
+	@ if ( grep 'LaTeX Warning: Label(s) may' $*.log > /dev/null ); \
+	then $(LATEX) $* ; fi
+	@ if ( grep 'LaTeX Warning: Citation' $*.log > /dev/null ); \
+	then bibtex $* ; $(LATEX) $* ; fi
+	@ if ( grep 'LaTeX Warning: Label(s) may' $*.log > /dev/null ); \
+	then $(LATEX) $* ; fi
+	@ if ( grep 'LaTeX Warning: Label(s) may' $*.log > /dev/null ); \
+	then $(LATEX) $* ; fi
+	@ if ( grep 'Writing index file' $*.log > /dev/null ); \
+	then makeindex $* ; $(LATEX) $* ; fi
+	@ if ( grep 'LaTeX Warning: Label(s) may' $*.log > /dev/null ); \
+	then $(LATEX) $* ; fi
+	@ if ( grep 'LaTeX Warning: Label(s) may' $*.log > /dev/null ); \
+	then $(LATEX) $* ; fi
+
+.dvi.ps:
+	$(DVIPS) -t letter -o $*.ps $*
+
+.eps.pdf:
+	epstopdf $*.eps
+
+.dot.eps:
+	dot -Tps -o $*.eps $*.dot 
+
+.w.tex: /afs/nd.edu/user11/jsiek/.jweb
+	jweb -np $*.w
+
+BOOST		= $(HOME)/boost
+BOOST_ALGO	= $(HOME)/boost.algorithm
+CXX		= c++
+INCLUDES	= -I$(BOOST) -I$(BOOST_ALGO)
+#OPT		= +K2 --display_error_number --diag_suppress=186
+OPT		= -Wall -Wno-long-double -ftemplate-depth-30
+CXXFLAGS	= $(OPT) $(INCLUDES)
+
+.cpp.o:
+	$(CXX) $(CXXFLAGS) $< -c
+
+
+JWEB	= isomorphism-impl.w isomorphism-impl-v3.w
+DOT	= out.dot in.dot iso-eg.dot iso-eg2.dot
+EPS_GEN	= $(DOT:.dot=.eps)
+WEBTEX	= $(JWEB:.w=.tex)
+PDFPICT	= $(EPS_GEN:.eps=.pdf)
+
+default: isomorphism-impl-v3.$(RESULT)
+
+final: isomorphism-impl-v3.$(RESULT)
+	$(LATEX) isomorphism-impl-v3
+	csh ./mungeaux.csh *.aux
+	$(LATEX) isomorphism-impl-v3
+
+#isomorphism-impl.dvi: $(EPS_GEN) $(WEBTEX)
+#isomorphism-impl.ps: isomorphism-impl.dvi
+#isomorphism-impl.pdf: $(EPS_GEN) $(PDFPICT) $(WEBTEX)
+#isomorphism.hpp: isomorphism-impl.w isomorphism-impl.tex
+
+isomorphism-impl-v3.dvi: $(DOT) $(EPS_GEN) $(WEBTEX)
+isomorphism-impl-v3.ps: isomorphism-impl-v3.dvi
+isomorphism-impl-v3.pdf: $(EPS_GEN) $(PDFPICT) $(WEBTEX)
+
+isomorphism-v3.hpp: isomorphism-impl-v3.w isomorphism-impl-v3.tex
+
+out.dot: isomorphism-impl.tex
+in.dot: isomorphism-impl.tex
+
+isomorphism.o: isomorphism-v3.hpp isomorphism-impl-v3.w
+
+isomorphism: isomorphism.o
+	$(CXX) $(CXXFLAGS) $< -o $@ $(LIBS)
+
+isomorphism-v3.hpp: isomorphism-impl-v3.tex isomorphism-impl-v3.w
+eg1-iso.o: isomorphism-impl-v3.tex isomorphism-impl-v3.w
+
+eg1-iso: eg1-iso.o
+	$(CXX) $(CXXFLAGS) $< -o $@ $(LIBS)
+
+
+clean:
+	rm *.aux *.dvi $(EPS_GEN) $(PDFPICT)

doc/Monoid.html

@@ -0,0 +1,122 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2001
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Monoid</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><A NAME="concept:Monoid"></A>
+Monoid
+</H1>
+
+A <i>Monoid</i> is a concept that describes a simple kind of algebraic
+system. A <b>monoid</b> consists of a set of elements <i>S</i>, a
+binary operation, and an identity element. The C++ representation of a
+monoid consists of a function object that implements the binary
+operation, a set of objects that represent the elements of <i>S</i>,
+and an object that represents the identity element.
+
+
+<H3>Refinement of</H3>
+
+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.boost.org/sgi/stl/BinaryFunction.html">BinaryFunction</a>.
+
+<h3>Notation</h3>
+
+<Table>
+<TR>
+<TD><tt>X</tt></TD>
+<TD>Is the element type of the Monoid.</TD>
+</TR>
+
+<TR>
+<TD><tt>a, b</tt></TD>
+<TD>are objects of type <tt>X</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>op</tt></TD>
+<TD>Is the function object implementing the Monoid operation.</TD>
+</TR>
+
+<TR>
+<TD><tt>i</tt></TD>
+<TD>is an object of type <tt>X</tt> and is the identity element
+for the Monoid.</TD>
+</TR>
+
+
+</table>
+
+<h3>Valid Expressions</h3>
+
+<Table border>
+
+<tr>
+<td><a name="sec:source"><TT>op(a,&nbsp;b)</TT></a></TD>
+<TD>See below for semantics.<br>
+Return type: <TT>X</TT>
+</TD>
+</TR>
+
+<tr>
+<TD><TT>a&nbsp;==&nbsp;b</TT></TD>
+<TD>Returns true if <tt>a</tt> and <tt>b</tt> represent
+     the same element of <i>S</i>.<br>
+Return type: <TT>bool</TT>
+</TD>
+</TR>
+
+<tr>
+<TD><TT>a&nbsp;!=&nbsp;b</TT></TD>
+<TD>Returns true if <tt>a</tt> and <tt>b</tt> represent
+     different elements of <i>S</i>.<br>
+Return type: <TT>bool</TT>
+</TD>
+</TR>
+
+</TABLE>
+
+<P>
+
+<H3>Invariants</H3>
+
+<UL>
+  <li>Closure<br>
+     The result of <tt>op(a, b)</tt> is also an element of <i>S</i>.
+  <li>Associativity<br>
+     <tt>op(op(a, b), c) == op(a, op(b, c))</tt>
+  <li>Definition of Identity Element<br>
+       <tt>op(a, i) == a</tt>
+</UL>
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
+
+</BODY>
+</HTML> 

doc/MutableGraph.html

@@ -0,0 +1,299 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>MutableGraph</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+
+<H2><A NAME="sec:MutableGraph"></A>
+MutableGraph
+</H2>
+
+A MutableGraph can be changed via the addition or removal of
+edges and vertices.
+
+<H3>Refinement of</H3>
+
+<a href="./Graph.html">Graph</a>
+
+<h3>Notation</h3>
+
+<Table>
+<TR>
+<TD><tt>G</tt></TD>
+<TD>A type that is a model of Graph.</TD>
+</TR>
+
+<TR>
+<TD><tt>g</tt></TD>
+<TD>An object of type <tt>G</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>e</tt></TD>
+<TD>An object of type <tt>boost::graph_traits&lt;G&gt;::edge_descriptor</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>u,v</tt></TD>
+<TD>are objects of type <tt>boost::graph_traits&lt;G&gt;::vertex_descriptor</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>iter</tt></TD>
+<TD>is an object of type <tt>boost::graph_traits&lt;G&gt;::out_edge_iterator</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>p</tt></TD>
+<TD>is an object of a type that models <a
+href="http://www.boost.org/sgi/stl/Predicate.html">Predicate</a>
+and whose argument type matches the <tt>edge_descriptor</tt> type. 
+</TR>
+
+</table>
+
+<H3>Valid Expressions</H3>
+
+<table border>
+
+<tr>
+<TD><a name="sec:add-edge"><TT>add_edge(u,&nbsp;v,&nbsp;g)</TT></a></TD>
+<TD>
+Inserts the edge <i>(u,v)</i> into the graph, and returns an edge
+descriptor pointing to the new edge. If the graph disallows parallel
+edges, and the edge <i>(u,v)</i> is already in the graph, then the
+<tt>bool</tt> flag returned is <tt>false</tt> and the returned edge
+descriptor points to the already existing edge.  Note that for
+undirected graphs, <i>(u,v)</i> is the same edge as <i>(v,u)</i>, so
+after a call to the function <tt>add_edge()</tt>, this implies that
+edge <i>(u,v)</i> will appear in the out-edges of <i>u</i> and
+<i>(u,v)</i> (or equivalently <i>(v,u)</i>) will appear in the
+out-edges of <i>v</i>.  Put another way, <i>v</i> will be adjacent to
+<i>u</i> and <i>u</i> will be adjacent to <i>v</i>.
+<br>
+Return type: <TT>std::pair&lt;edge_descriptor, bool&gt;</TT>
+</TD>
+</tr>
+
+<tr>
+<TD><a name="sec:remove_edge"><TT>remove_edge(u,&nbsp;v,&nbsp;g)</TT></a></TD>
+<TD>
+Remove the edge <i>(u,v)</i> from the graph. If the
+graph allows parallel edges this remove all occurrences of
+<i>(u,v)</i>.<br>
+Return type: <TT>void</TT><br>
+Precondition: <i>u</i> and <i>v</i> are vertices in the graph.<br>
+Postcondition: <i>(u,v)</i> is no longer in the edge set for
+<TT>g</TT>.<br>
+</TD>
+</TR>
+
+
+<tr>
+<TD><TT>remove_edge(e,&nbsp;g)</TT></TD>
+<TD>Remove the edge <i>e</i> from the graph.<br>
+Return type: <TT>void</TT><br>
+Precondition: <i>e</i> is an edge in the graph.<br>
+Postcondition: <i>e</i> is no longer in the edge set for <TT>g</TT>.
+</TD>
+</TR>
+
+<tr>
+<TD><TT>remove_edge(iter,&nbsp;g)</TT></TD>
+<TD>Remove the edge pointed to be <tt>iter</tt> from the graph.  This
+expression is only required when the graph also models <a
+href="./IncidenceGraph.html">IncidenceGraph</a>.<br>
+Return type: <TT>void</TT><br>
+Precondition: <tt>*iter</tt> is an edge in the graph.<br>
+Postcondition: <tt>*iter</tt> is no longer in the edge set for <TT>g</TT>.
+</TD>
+</TR>
+
+<tr>
+<TD><TT>remove_edge_if(p,&nbsp;g)</TT></TD>
+<TD>Remove all the edges from graph <tt>g</tt> for which
+the predicate <tt>p</tt> returns true.<br>
+Return type: <TT>void</TT>
+</TD>
+</TR>
+
+<tr>
+<TD><TT>remove_out_edge_if(u,&nbsp;p,&nbsp;g)</TT></TD>
+<TD>Remove all the out-edges of vertex <tt>u</tt> for which the
+predicate <tt>p</tt> returns true. This expression is only required
+when the graph also models <a
+href="./IncidenceGraph.html">IncidenceGraph</a>.<br>
+Return type: <TT>void</TT>
+</TD>
+</TR>
+
+<tr>
+<TD><TT>remove_in_edge_if(u,&nbsp;p,&nbsp;g)</TT></TD>
+<TD>Remove all the in-edges of vertex <tt>u</tt> for which the
+predicate <tt>p</tt> returns true. This expression is only required when the
+graph also models <a
+href="./BidirectionalGraph.html">BidirectionalGraph</a>.<br>
+Return type: <TT>void</TT>
+</TD>
+</TR>
+
+
+<tr>
+<TD><a name="sec:add-vertex"><TT>add_vertex(g)</TT></a></TD>
+<TD>
+Add a new vertex to the graph. The <TT>vertex_descriptor</TT> for the
+new vertex is returned.<br>
+Return type: <TT>vertex_descriptor</TT>
+</TD>
+</TR>
+
+
+<tr>
+<TD><TT>clear_vertex(u,&nbsp;g)</TT></TD>
+<TD>
+Remove all edges to and from vertex <tt>u</tt> from the graph.<br>
+Return type: <TT>void</TT><br>
+Precondition: <tt>u</tt> is a valid vertex descriptor of <TT>g</TT>.<br>
+Postcondition: <tt>u</tt> does not appear as a source or target of
+any edge in <TT>g</TT>.
+</TD>
+</TR>
+
+<tr>
+<TD><a name="sec:remove-vertex"><TT>remove_vertex(u,&nbsp;g)</TT></a></TD>
+<TD>
+Remove <i>u</i> from the vertex set of the graph. Note that undefined
+behavior may result if there are edges remaining in the graph who's
+target is <i>u</i>. Typically the <TT>clear_vertex()</TT> function
+should be called first.<br>
+Return type: <TT>void</TT><br>
+Precondition: <TT>u</TT> is a valid vertex descriptor of <TT>g</TT>.<br>
+Postcondition: <TT>num_vertices(g)</TT> is one less, <TT>u</TT>
+no longer appears in the vertex set of the graph and it
+is no longer a valid vertex descriptor.
+</TD>
+</TR>
+</TABLE>
+
+<P>
+</LI>
+</UL>
+
+<P>
+
+<H3>Complexity Guarantees</H3>
+
+<P>
+
+<UL>
+<LI>Edge insertion must be either amortized constant time or it
+ can be <i>O(log(E/V))</i> if the insertion also checks to
+  prevent the addition of parallel edges (which is a ``feature'' of
+  some graph types).
+</LI>
+<LI>Edge removal is guaranteed to be <i>O(E)</i>.</LI>
+<LI>Vertex insertion is guaranteed to be amortized constant time.</LI>
+<LI>Clearing a vertex is <i>O(E + V)</i>.</LI>
+<LI>Vertex removal is <i>O(E + V)</i>.</LI>
+</UL>
+
+<H3>Models</H3>
+
+<UL>
+<LI><TT>adjacency_list</TT>
+</LI>
+</UL>
+
+
+<H3>Concept Checking Class</H3>
+
+<PRE>
+  template &lt;class G&gt;
+  struct MutableGraphConcept
+  {
+    typedef typename boost::graph_traits&lt;G&gt;::edge_descriptor edge_descriptor;
+    void constraints() {
+      v = add_vertex(g);
+      clear_vertex(v, g);
+      remove_vertex(v, g);
+      e_b = add_edge(u, v, g);
+      remove_edge(u, v, g);
+      remove_edge(e, g);
+    }
+    G g;
+    edge_descriptor e;
+    std::pair&lt;edge_descriptor, bool&gt; e_b;
+    typename boost::graph_traits&lt;G&gt;::vertex_descriptor u, v;
+    typename boost::graph_traits&lt;G&gt;::out_edge_iterator iter;
+  };
+
+  template &lt;class edge_descriptor&gt;
+  struct dummy_edge_predicate {
+    bool operator()(const edge_descriptor& e) const {
+      return false;
+    }
+  };
+
+  template &lt;class G&gt;
+  struct MutableIncidenceGraphConcept
+  {
+    void constraints() {
+      BOOST_CONCEPT_ASSERT(( MutableGraph&lt;G&gt; ));
+      remove_edge(iter, g);
+      remove_out_edge_if(u, p, g);
+    }
+    G g;
+    typedef typename boost::graph_traits&lt;G&gt;::edge_descriptor edge_descriptor;
+    dummy_edge_predicate&lt;edge_descriptor&gt; p;
+    typename boost::graph_traits&lt;G&gt;::vertex_descriptor u;
+    typename boost::graph_traits&lt;G&gt;::out_edge_iterator iter;
+  };
+
+  template &lt;class G&gt;
+  struct MutableBidirectionalGraphConcept
+  {
+    void constraints() {
+      BOOST_CONCEPT_ASSERT(( MutableIncidenceGraph&lt;G&gt; ));
+      remove_in_edge_if(u, p, g);
+    }
+    G g;
+    typedef typename boost::graph_traits&lt;G&gt;::edge_descriptor edge_descriptor;
+    dummy_edge_predicate&lt;edge_descriptor&gt; p;
+    typename boost::graph_traits&lt;G&gt;::vertex_descriptor u;
+  };
+
+  template &lt;class G&gt;
+  struct MutableEdgeListGraphConcept
+  {
+    void constraints() {
+      BOOST_CONCEPT_ASSERT(( MutableGraph&lt;G&gt; ));
+      remove_edge_if(p, g);
+    }
+    G g;
+    typedef typename boost::graph_traits&lt;G&gt;::edge_descriptor edge_descriptor;
+    dummy_edge_predicate&lt;edge_descriptor&gt; p;
+  };
+</PRE>
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 

doc/MutablePropertyGraph.html

@@ -1,20 +1,16 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  Silicon Graphics makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>MutablePropertyGraph</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -95,16 +91,16 @@ the value of the properties can be given.
 <table border>
 
 <tr>
-<TD><TT>add_edge(g,&nbsp;u,&nbsp;v,&nbsp;ep)</TT></TD>
+<TD><TT>add_edge(u,&nbsp;v,&nbsp;ep,&nbsp;g)</TT></TD>
 <TD>Inserts the edge <i>(u,v)</i> into the graph, and
-copies object <TT>ep</TT> into the property property for that edge.<br>
+copies object <TT>ep</TT> into the property for that edge.<br>
 Return type: <TT>std::pair&lt;edge_descriptor, bool&gt;</TT></TD>
 </TR>
 
 <tr>
-<TD><TT>add_vertex(g,&nbsp;vp)</TT></TD>
+<TD><TT>add_vertex(vp,&nbsp;g)</TT></TD>
 <TD>
-Add a new vertex to the graph and copy <TT>vp</TT> into the property
+Add a new vertex to the graph and copy <TT>vp</TT> into the
 property for the new vertex. The <TT>vertex_descriptor</TT> for the new
 vertex is returned.<br>
 Return type: <TT>vertex_descriptor</TT>
@@ -125,13 +121,13 @@ Return type: <TT>vertex_descriptor</TT>
 <P>
 <PRE>
   template &lt;class G&gt;
-  struct MutablePropertyGraph_concept
+  struct MutablePropertyGraphConcept
   {
     typedef typename boost::graph_traits&lt;G&gt;::edge_descriptor edge_descriptor;
     void constraints() {
-      REQUIRE(G, MutableGraph);
-      v = add_vertex(g, vp);
-      p = add_edge(g, u, v, ep);
+      BOOST_CONCEPT_ASSERT(( MutableGraphConcept&lt;G&gt; ));
+      v = add_vertex(vp, g);
+      p = add_edge(u, v, ep, g);
     }
     G g;
     std::pair&lt;edge_descriptor, bool&gt; p;
@@ -146,8 +142,8 @@ Return type: <TT>vertex_descriptor</TT>
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>, Univ.of Notre Dame (<A HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
 </TD></TR></TABLE>
 
 </BODY>

doc/PlanarEmbedding.html

@@ -0,0 +1,178 @@
+<html><head><!-- Copyright 2007 Aaron Windsor
+     
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+    
+  -->
+<title>Planar Embedding Concept</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>Planar Embedding Concept</h1>
+
+
+A planar embedding is an important intermediate representation of a drawing
+of a planar graph. Instead of specifying the absolute positions of the vertices
+and edges in the plane, a planar embedding specifies their positions relative 
+to one another. A planar embedding consists of a sequence, for each vertex in 
+the graph, of all of the edges incident on that vertex in the order in which 
+they are to be drawn around that vertex.
+<p>
+A planar embedding is a refinement of 
+<a href="../../property_map/doc/LvaluePropertyMap.html">LValuePropertyMap</a> that
+places additional restrictions the <tt>value_type</tt> used in the property
+map.
+
+</p><h3>Notation</h3>
+
+<table>
+<tbody>
+
+<tr> 
+<td> <tt>Embedding</tt> </td>  
+<td> is a type that models the Planar Embedding concept.</td>
+</tr>
+
+<tr> 
+<td> <tt>embedding</tt> </td>
+<td> is an object of type <tt>Embedding</tt>. </td>
+</tr>
+
+<tr> 
+<td> <tt>Graph</tt> </td>  
+<td> is the type of the underlying graph.</td>
+</tr>
+
+<tr> 
+<td> <tt>e</tt> </td>  
+<td> is an object of type <tt>graph_traits&lt;Graph&gt;::edge_descriptor</tt>. 
+</td>
+</tr>
+
+<tr>
+<td> <tt>v</tt> </td>
+<td> is an object of type <tt>graph_traits&lt;Graph&gt;::vertex_descriptor
+</tt>.</td>
+
+</tr><tr>
+<td> 
+
+</td></tr></tbody></table>
+
+
+<h3>Associated Types</h3>
+
+<table border="1">
+
+<tbody><tr> 
+<td> Const Iterator  </td>
+<td> <tt>boost::property_traits&lt;Embedding&gt;::value_type::const_iterator
+</tt>
+</td>
+<td> The iterator type used to iterate over the ordering of the edges in the 
+planar embedding of a particular vertex
+</td>
+</tr>
+
+</tbody></table>
+
+<h3>Valid Expressions</h3>
+
+<p>
+
+<table border="1">
+
+<tbody><tr><th>Expression</th><th>Return Type</th><th>Description</th>
+
+</tr><tr> 
+<td> <tt>embedding[v].begin()</tt>  </td>
+<td> <tt>boost::property_traits&lt;Embedding&gt;::value_type::const_iterator
+     </tt></td>
+<td> Returns an iterator to the beginning of the range of edges in the 
+     embedding around vertex v</td>
+</tr>
+
+<tr> 
+<td> <tt>embedding[v].end()</tt>  </td>
+<td> <tt>boost::property_traits&lt;Embedding&gt;::value_type::const_iterator
+     </tt></td>
+<td> Returns an iterator to the end of the range of edges in the 
+     embedding around vertex v</td>
+</tr>
+
+<tr> 
+<td> <tt>embedding[v].clear()</tt>  </td>
+<td> <tt>void</tt></td>
+<td> Clears all edges in the embedding around a vertex <tt>v</tt></td>
+</tr>
+
+<tr> 
+<td> <tt>embedding[v].push_back(e)</tt>  </td>
+<td> <tt>void</tt></td>
+<td> Adds an edge <tt>e</tt> to the end of the sequence of embedded edges 
+     around the vertex <tt>v</tt> </td>
+</tr>
+
+</tbody></table>
+
+</p><h3>Complexity Guarantees</h3>
+
+Starting with an empty embedding, any mixed sequence of <i>n</i> calls to a
+particular vertex's <tt>push_back</tt> and <tt>clear</tt> should take 
+<i>O(n)</i> time.
+
+<h3>Models</h3>
+
+Any LValue property map that maps vertices to a <tt>std::vector</tt>, 
+<tt>std::list</tt>, or <tt>std::deque</tt> models this
+concept. Below is an example of using this approach to create a model of
+PlanarEmbedding:
+
+<pre>
+#include &lt;boost/property_map/property_map.hpp&gt;
+#include &lt;vector&gt;
+
+...
+
+// Assume a graph type "Graph" defined somewhere above and
+// an instance of Graph in a variable g.
+
+// A typedef for the storage - a vector of vectors of edge descriptors
+typedef 
+    std::vector&lt; std::vector&lt; graph_traits&lt;Graph&gt;::edge_descriptor &gt; &gt;
+    planar_embedding_storage_t;
+
+// A typedef for the iterator property map, assuming the graph has
+// an interior vertex index map
+typedef
+    boost::iterator_property_map&lt; planar_embedding_storage_t::iterator,
+                                  property_map&lt;Graph, vertex_index_t&gt;::type
+                                &gt;
+    planar_embedding_t;
+
+// Create an instance of the storage and the property map
+planar_embedding_storage_t planar_embedding_storage(num_vertices(g));
+planar_embedding_t planar_embedding(planar_embedding_storage.begin(),
+                                    get(vertex_index, g)
+                                    );
+
+// planar_embedding can now be passed to any function expecting a model
+// of PlanarEmbedding.
+</pre>
+
+<p>
+
+<br>
+</p><hr>
+Copyright © 2007 Aaron Windsor (<a href="mailto:aaron.windsor@gmail.com">
+aaron.windsor@gmail.com</a>) 
+
+</body></html>

doc/PlanarFaceVisitor.html

@@ -0,0 +1,148 @@
+<HTML>
+<!-- Copyright 2007 Aaron Windsor
+     
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+    
+  -->
+<HEAD>
+<TITLE>Planar Face Visitor Concept</TITLE>
+</HEAD>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1>Planar Face Visitor Concept</H1>
+
+This concept defines the visitor interface for 
+<a href="./planar_face_traversal.html"><tt>planar_face_traversal</tt></a>. 
+Users can define a class with the Planar Face Visitor interface and pass an 
+object of the class to <tt>planar_face_traversal</tt>, thereby augmenting the 
+actions taken during the traversal. Note that objects passed to 
+<tt>planar_face_traversal</tt> are passed by reference.
+
+<h3>Notation</h3>
+
+<table>
+<tbody><tr>
+<td><tt>V</tt></td>
+<td>A type that is a model of Planar Face Visitor.</td>
+</tr>
+
+<tr>
+<td><tt>vis</tt></td>
+<td>An object of type <tt>V</tt>.</td>
+</tr>
+
+<tr>
+<td><tt>G</tt></td>
+<td>A type that is a model of Graph.</td>
+</tr>
+
+<tr>
+<td><tt>e</tt></td>
+<td>An object of type <tt>boost::graph_traits&lt;G&gt;::edge_descriptor</tt>.
+</td>
+</tr>
+
+<tr>
+<td><tt>v</tt></td>
+<td>An object of type <tt>boost::graph_traits&lt;G&gt;::vertex_descriptor</tt>.
+</td>
+</tr>
+
+</tbody></table>
+
+
+<h3>Valid Expressions</h3>
+
+<table border="1">
+<tbody><tr>
+<th>Name</th><th>Expression</th><th>Return Type</th><th>Description</th>
+</tr>
+
+<tr>
+<td>Begin Traversal</td>
+<td><tt>vis.begin_traversal()</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked once per traversal, before the traversal begins.
+</td>
+</tr>
+
+<tr>
+<td>Begin Face</td>
+<td><tt>vis.begin_face()</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked once for each face, before any vertices or edges on the face 
+are visited. 
+</td>
+</tr>
+
+<tr>
+<td>Next Vertex</td>
+<td><tt>vis.next_vertex(v)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked when a vertex is encountered while traversing a face.
+</td>
+</tr>
+
+
+<tr>
+<td>Next Edge</td>
+<td><tt>vis.next_edge(e)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked when an edge is encountered while traversing a face.
+</td>
+</tr>
+
+<tr>
+<td>End Face</td>
+<td><tt>vis.end_face()</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked once for each face, after all vertices and edges on the face 
+are visited.
+</td>
+</tr>
+
+
+<tr>
+<td>End Traversal</td>
+<td><tt>vis.end_traversal()</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked once per traversal, after the traversal ends.
+</td>
+</tr>
+
+</tbody></table>
+
+<h3>Models</h3>
+
+<ul>
+ <li> The file <a href="../../../boost/graph/planar_face_traversal.hpp">
+<tt>planar_face_traversal.hpp</tt></a> contains a class 
+<tt>planar_face_traversal_visitor</tt> that implements empty actions for
+all event points of a Planar Face Visitor. In the case where only a few of the 
+event points of Planar Face Visitor need to be implemented, one can derive from
+<tt>planar_face_traversal_visitor</tt> and only implement the necessary event 
+points. <li> The implementation of <a href="./make_maximal_planar.html">
+<tt>make_maximal_planar</tt></a> uses a <tt>triangulation_visitor</tt> that is 
+a model of Planar Face Visitor.
+</li>
+</ul>
+
+<br>
+<HR>
+Copyright &copy; 2007 Aaron Windsor (<a href="mailto:aaron.windsor@gmail.com">
+aaron.windsor@gmail.com</a>)
+</BODY>
+</HTML> 

doc/PropertyGraph.html

@@ -1,20 +1,16 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  Silicon Graphics makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>PropertyGraph</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -26,7 +22,7 @@ PropertyGraph
 A PropertyGraph is a graph that has some property associated with each
 of the vertices or edges in the graph. As a given graph may have
 several properties associated with each vertex or edge, a tag is used
-to identity which property is being accessed.  The graph provides a
+to identify which property is being accessed.  The graph provides a
 function which returns a property map object.
 
 <P>
@@ -70,13 +66,13 @@ function which returns a property map object.
 </TR>
 
 <TR>
-<TD><tt>Property</tt></TD>
-<TD>A type that models the <a href="./Property.html">Property</a> concept.</TD>
+<TD><tt>PropertyTag</tt></TD>
+<TD>A type that models the <a href="./PropertyTag.html">PropertyTag</a> concept.</TD>
 </TR>
 
 <TR>
 <TD><tt>p</tt></TD>
-<TD>An object of type <tt>Property</tt>.</td>
+<TD>An object of type <tt>PropertyTag</tt>.</td>
 </TR>
 
 <TR>
@@ -91,18 +87,19 @@ function which returns a property map object.
 <table border>
 
 <tr>
-<td><pre>boost::property_map&lt;G, Property&gt;::type</pre>
+<td><pre>boost::property_map&lt;G, PropertyTag&gt;::type</pre>
 The type of the property map for the property specified by
-<TT>Property</TT>.  This type must be a model of <a
-href="../../property_map/ReadWritePropertyMap.html">ReadWritePropertyMap</a> with a key type the same as the graph's vertex or descriptor type.
+<TT>PropertyTag</TT>.  This type must be a model of <a
+href="../../property_map/doc/ReadWritePropertyMap.html">ReadWritePropertyMap</a> 
+with a key type the same as the graph's vertex or edge descriptor type.
 </td>
 </tr>
 
 <tr>
-<td><pre>boost::property_map&lt;G, Property&gt;::const_type</pre>
+<td><pre>boost::property_map&lt;G, PropertyTag&gt;::const_type</pre>
 The type of the const property map for the property specified by
-<TT>Property</TT>. This type must be a model of <a
-href="../../property_map/ReadablePropertyMap.html">ReadablePropertyMap</a>
+<TT>PropertyTag</TT>. This type must be a model of <a
+href="../../property_map/doc/ReadablePropertyMap.html">ReadablePropertyMap</a>
 with a key type the same as the graph's vertex or edge descriptor type.
 </td>
 </tr>
@@ -117,16 +114,16 @@ with a key type the same as the graph's vertex or edge descriptor type.
 <td> <TT>get(p,&nbsp;g)</TT> </td>
 <td>
 Returns the property map for the property specified by the
-<tt>Property</tt> type. The object <tt>p</tt> is only used to
+<tt>PropertyTag</tt> type. The object <tt>p</tt> is only used to
 carry the type.<br>
-Return type: <TT>boost::property_map&lt;G,&nbsp;Property&gt;::type</TT> if <TT>g</TT> is mutable and <br><TT>boost::property_map&lt;G,&nbsp;Property&gt;::const_type</TT> otherwise.
+Return type: <TT>boost::property_map&lt;G,&nbsp;PropertyTag&gt;::type</TT> if <TT>g</TT> is mutable and <br><TT>boost::property_map&lt;G,&nbsp;PropertyTag&gt;::const_type</TT> otherwise.
 </td>
 </TR>
 
 <tr>
 <td> <TT>get(p,&nbsp;g,&nbsp;x)</TT> </td>
 <td>
-Returns the property value (specified by the <tt>Property</tt> type)
+Returns the property value (specified by the <tt>PropertyTag</tt> type)
 associated with object <tt>x</tt> (a vertex or edge).
 The object <tt>p</tt> is only used to carry the type.
 This function is equivalent to:<br>
@@ -138,7 +135,7 @@ Return type: <tt>boost::property_traits&lt;Map&gt;::value_type</tt>
 <tr>
 <td> <TT>put(p,&nbsp;g,&nbsp;x,&nbsp;v)</TT> </td>
 <td>
-Set the property (specified by the <tt>Property</tt> type)
+Set the property (specified by the <tt>PropertyTag</tt> type)
 associated with object <tt>x</tt> (a vertex or edge) to
 the value <tt>v</tt>. The object <tt>p</tt> is only used to carry the type.
 This function is equivalent to:<br>
@@ -162,32 +159,32 @@ The <tt>get()</tt> property map function must be constant time.
 
 
 <UL>
-<LI><tt>adjacency_list</tt> with <tt>VertexProperty=property&lt;vertex_distance_t,int,property&lt;vertex_in_degree_t,int&gt; &gt;</tt> and <tt>Property=vertex_distance_t</tt>.</li>
-<li><tt>adjacency_list</tt> with <tt>VertexProperty=property&lt;vertex_distance_t,int,property&lt;vertex_in_degree_t,int&gt; &gt;</TT> and <tt>Property=vertex_in_degree_t</tt>.</li>
+<LI><tt>adjacency_list</tt> with <tt>VertexProperty=property&lt;vertex_distance_t,int,property&lt;vertex_in_degree_t,int&gt; &gt;</tt> and <tt>PropertyTag=vertex_distance_t</tt>.</li>
+<li><tt>adjacency_list</tt> with <tt>VertexPropertyTag=property&lt;vertex_distance_t,int,property&lt;vertex_in_degree_t,int&gt; &gt;</TT> and <tt>PropertyTag=vertex_in_degree_t</tt>.</li>
 </UL>
 
 
 <H3>Concept Checking Class</H3>
 
 <PRE>
-  template &lt;class Graph, class X, class Property&gt;
-  struct PropertyGraph_concept
+  template &lt;class Graph, class X, class PropertyTag&gt;
+  struct PropertyGraphConcept
   {
-    typedef typename property_map&lt;G, Property&gt;::type Map;
-    typedef typename property_map&lt;G, Property&gt;::const_type const_Map;
+    typedef typename property_map&lt;G, PropertyTag&gt;::type Map;
+    typedef typename property_map&lt;G, PropertyTag&gt;::const_type const_Map;
     void constraints() {
-      REQUIRE(G, Graph);
-      REQUIRE2(Map, X, ReadWritePropertyMap);
-      REQUIRE2(const_Map, X, ReadablePropertyMap);
+      BOOST_CONCEPT_ASSERT(( GraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept&lt;Map, X&gt; ));
+      BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept&lt;const_Map, X&gt; ));
 
-      Map pmap = get(Property(), g);
-      pval = get(Property(), g, x);
-      put(Property(), g, x, pval);
+      Map pmap = get(PropertyTag(), g);
+      pval = get(PropertyTag(), g, x);
+      put(PropertyTag(), g, x, pval);
       ignore_unused_variable_warning(pmap);
     }
     void const_constraints(const G&amp; g) {
-      const_Map pmap = get(Property(), g);
-      pval = get(Property(), g, x);
+      const_Map pmap = get(PropertyTag(), g);
+      pval = get(PropertyTag(), g, x);
       ignore_unused_variable_warning(pmap);
     }
     G g;
@@ -205,8 +202,8 @@ The <tt>get()</tt> property map function must be constant time.
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>, Univ.of Notre Dame (<A HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
 </TD></TR></TABLE>
 
 </BODY>

doc/PropertyTag.html

@@ -0,0 +1,117 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Property</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H2><A NAME="concept:PropertyTag"></A>
+PropertyTag
+</H2>
+
+A Property Tag is a type used to name or identify properties that are
+attached to the vertices and edges of a graph. A Property type is not
+the type of the actual property values. Objects of the Property type
+are not used except to carry the type information which specifies the
+property. See the section about <A
+href="using_adjacency_list.html#sec:custom-edge-properties"> Custom
+Edge Properties</a> for a description of how to define your own
+property tags.
+
+
+<h3>Associated Types</h3>
+
+<table border>
+
+<tr>
+<td>Property Kind </td>
+<td><TT>property_kind&lt;PropertyTag&gt;::type</TT> </td>
+<td>
+
+This specifies whether the property is a <a
+name="VertexPropertyTag"><b>Vertex Property Tag</b></a>
+(<tt>vertex_property_tag</tt>), an <a
+name="EdgePropertyTag"><b>Edge Property Tag</b></a> (<tt>edge_property_tag</tt>), or
+a <a name="GraphPropertyTag"><b>Graph Property Tag</b></a> which is attached to the
+graph object itself (<tt>graph_property_tag</tt>). The tags are
+defined in <a
+href="../../../boost/graph/properties.hpp"><tt>boost/graph/properties.hpp</tt></a>. The <tt>property_kind</tt> traits class is defined in <a href="../../../boost/pending/property.hpp"><tt>boost/pending/property.hpp</tt></a>.
+
+</td>
+</tr>
+
+<tr>
+<td>Property ID Number </td>
+<td><TT>property_num&lt;PropertyTag&gt;::value</TT> </td>
+<td>
+This is needed as a workaround when using compilers that do not
+support partial specialization (and hence prevent us from using
+<tt>boost::is_same</tt> to detect if two property tags are the same).
+The <tt>property_num</tt> traits class is defined in <a
+href="../../../boost/pending/property.hpp"><tt>boost/pending/property.hpp</tt></a>.
+</td>
+</tr>
+
+</table>
+
+<h3>Refinement of</h3>
+
+<a
+href="http://www.boost.org/sgi/stl/DefaultConstructible.html">Default Constructible</a> 
+
+
+<h3>Models</h3>
+
+The following models of the Property Tag concept are defined
+in <a
+href="../../../boost/graph/properties.hpp"><tt>boost/graph/properties.hpp</tt></a>.
+
+<ul>
+  <li><tt>vertex_index_t</tt></li>
+  <li><tt>edge_index_t</tt></li>
+  <li><tt>graph_name_t</tt></li>
+  <li><tt>vertex_name_t</tt></li>
+  <li><tt>edge_name_t</tt></li>
+  <li><tt>edge_weight_t</tt></li>
+  <li><tt>vertex_distance_t</tt></li>
+  <li><tt>vertex_color_t</tt></li>
+  <li><tt>vertex_degree_t</tt></li>
+  <li><tt>vertex_out_degree_t</tt></li>
+  <li><tt>vertex_in_degree_t</tt></li>
+  <li><tt>vertex_discover_time_t</tt></li>
+  <li><tt>vertex_finish_time_t</tt></li>
+</ul>
+
+<h3>See Also</h3>
+
+<a href="./PropertyGraph.html">PropertyGraph</a>
+and
+<a href="../../property_map/doc/property_map.html">Property Map Concepts</a>
+
+<h3>Notes</h3>
+
+On compilers that do not support partial specialization, each Property
+type is also required to specialize
+<tt>property_num&lt;PropertyTag&gt;</tt> to contain an enum named
+<tt>value</tt> which uniquely identifies the property type.
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 

doc/TSPTourVisitor.html

@@ -0,0 +1,99 @@
+<HTML>
+<!--
+  Copyright (c) Matyas Egyhazy 2008
+  Distributed under the Boost Software License, Version 1.0.
+  (See accompanying file LICENSE_1_0.txt or copy at
+  http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: TSP Tour Visitor</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b"
+        ALINK="#ff0000">
+<IMG SRC="../../../boost.png"
+     ALT="C++ Boost" width="277" height="86">
+
+<BR Clear>
+
+<H1>TSP Tour Visitor concept</H1>
+
+This concept defines the visitor interface for <a
+href="./metric_tsp_approx.html"><tt>metric_tsp_approx()</tt></a>
+and related algorithms. The user can create a class that matches this
+interface, and then pass objects of the class into
+<tt>metric_tsp_approx()</tt> to augment the actions taken during
+the search.
+
+<h3>Refinement of</h3>
+
+none
+
+<h3>Notation</h3>
+
+<Table>
+<TR>
+<TD><tt>V</tt></TD>
+<TD>A type that is a model of Dijkstra Visitor.</TD>
+</TR>
+
+<TR>
+<TD><tt>vis</tt></TD>
+<TD>An object of type <tt>V</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>G</tt></TD>
+<TD>A type that is a model of Graph.</TD>
+</TR>
+
+<TR>
+<TD><tt>g</tt></TD>
+<TD>An object of type <tt>G</tt>.</TD>
+</TR>
+
+<TR>
+<TD><tt>v</tt></TD>
+<TD>An object of type <tt>boost::graph_traits&lt;G&gt;::vertex_descriptor</tt>.</TD>
+</TR>
+
+</table>
+
+<h3>Associated Types</h3>
+
+none
+
+<p>
+
+<h3>Valid Expressions</h3>
+
+<table border>
+<tr>
+<th>Name</th><th>Expression</th><th>Return Type</th><th>Description</th>
+</tr>
+
+<tr>
+<td>Visit Vertex</td>
+<td><tt>vis.visit_vertex(v, g)</tt></td>
+<td><tt>void</tt></td>
+<td>
+This is invoked on each vertex of the graph when it is visited as part of the TSP tour.
+</td>
+</tr>
+
+</table>
+
+<h3>Models</h3>
+
+<ul>
+ <li><a href="tsp_tour_visitor.html"><tt>tsp_tour_visitor</tt></a>
+ <li><a href="tsp_tour_len_visitor.html"><tt>tsp_tour_len_tsp_visitor</tt></a>
+</ul>
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2008</TD><TD>
+Matyas Egyhazy</TD></TR></TABLE>
+
+</BODY>
+</HTML>

doc/UpdatableQueue.html

@@ -0,0 +1,100 @@
+<!DOCTYPE html>
+<!--
+            Copyright Daniel Trebbien 2010.
+ Distributed under the Boost Software License, Version 1.0.
+   (See accompanying file LICENSE_1_0.txt or the copy at
+         http://www.boost.org/LICENSE_1_0.txt)
+-->
+<html>
+<head>
+<title>UpdatableQueue</title>
+</head>
+<body> 
+<img src="../../../boost.png"  alt="C++ Boost">
+
+<h2><a name="concept:UpdatableQueue">UpdatableQueue</a></h2>
+
+<p>An <i>UpdatableQueue</i> is a refinement of the <a href="./Buffer.html">Buffer</a> concept that additionally requires that the Buffer be updatable.
+
+<p>Implicit in the definition is an ordering of values. Though access to the order is not required, types that model UpdatableQueue must document how an object of the type orders values so that a program may change the position of a given value in the ordering. For example, an UpdatableQueue may choose to order values by using a property map, and a value <tt>v1</tt> is considered less than a value <tt>v2</tt> if <tt><nobr>get(pm, v1) &lt; get(pm, v2)</nobr></tt>. A program can update the properties of values, thus changing the order of values in the UpdatableQueue, and notify the UpdatableQueue of the specific values that have a different position in the ordering by calling the <tt>update</tt> member of the UpdatableQueue on each.
+
+<p>A program that modifies the order must notify the UpdatableQueue of values that may have different positions in the ordering since they were inserted or last updated.
+
+<h3>Notation</h3>
+
+<table>
+<tr> <td> <tt>Q</tt> </td>  <td> is a type that models UpdatableQueue.       </td></tr>
+<tr> <td> <tt>T</tt> </td>  <td> is the value type of <tt>Q</tt>. </td></tr>
+</table>
+
+
+<h3>Members</h3>
+
+For a type to model the UpdatableQueue concept it must have the following members 
+in addition to the members that are required of types that model <a href="./Buffer.html">Buffer</a>:
+
+<p>
+
+<table border="1">
+
+<tr> <td><b>Member</b></td> <td><b>Description</b></td> </tr>
+
+<tr> <td> <a name="concept:UpdatableQueue:update"><tt>void update(const T& t)</tt></a> </td>
+     <td> Informs the UpdatableQueue that the program has modified the position of <tt>t</tt> in the ordering </td>
+     </tr>
+
+<tr> <td> <tt><i>unspecified-bool-type</i> contains(const T& t) const</tt> </td>
+     <td> Returns whether the queue contains <tt>t</tt> </td>
+     </tr>
+
+</table>
+
+<h3>Concept Checking Class</h3>
+
+<p><a href="../../../boost/graph/buffer_concepts.hpp"><tt>boost/graph/buffer_concepts.hpp</tt></a>
+
+<pre>
+  template &lt;class Q&gt;
+  struct UpdatableQueueConcept
+  {
+    void constraints() {
+      BOOST_CONCEPT_ASSERT(( Buffer&lt;Q&gt; ));
+      
+      q.update(g_ct);
+    }
+    
+    void const_constraints(const Q&amp; cq) {
+      if (cq.contains(g_ct));
+    }
+    
+    static const typename Buffer&lt;Q&gt;::value_type g_ct;
+    Q q;
+  };
+</pre>
+
+<h3>Futher Refinements</h3>
+
+<ul>
+<li><a href="#concept%3AUpdatablePriorityQueue">UpdatablePriorityQueue</a>
+<li><a href="./KeyedUpdatableQueue.html">KeyedUpdatableQueue</a>
+</ul>
+
+<h2><a name="concept:UpdatablePriorityQueue">UpdatablePriorityQueue</a></h2>
+<p>An <i>UpdatablePriorityQueue</i> is a slight refinement of <a href="#concept%3AUpdatableQueue">UpdatableQueue</a>
+that imposes the requirement that a program may not increase the position of a value that is held in the queue. That is,
+if a value <tt>v</tt> had position <i>n</i> in the ordering, a program may update the position of <tt>v</tt> only to 0, 1, ..., <i>n</i>&nbsp;-&nbsp;1, or <i>n</i>, where 0 is the top of the queue.
+
+<p>The behavior when a program attempts to increase a value's position in the ordering is undefined.
+
+<br>
+<hr>
+<table>
+<tr>
+<td>Copyright&nbsp;&copy;&nbsp;2010</td>
+<td>Daniel Trebbien (<a href="mailto:dtrebbien@gmail.com">dtrebbien@gmail.com</a>)
+</td>
+</tr>
+</table>
+
+</body>
+</html>

doc/VertexAndEdgeListGraph.html

@@ -1,20 +1,16 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  Silicon Graphics makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>VertexAndEdgeListGraph</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -52,11 +48,12 @@ requirements are added.
 <P>
 <PRE>
   template &lt;class G&gt;
-  struct VertexAndEdgeListGraph
+  struct VertexAndEdgeListGraphConcept
   {
-    CLASS_REQUIRES(G, VertexListGraph);
-    CLASS_REQUIRES(G, EdgeListGraph);
-    void constraints() { }
+    void constraints() {
+      BOOST_CONCEPT_ASSERT(( VertexListGraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept&lt;G&gt; ));
+    }
   };
 </PRE>
 
@@ -65,8 +62,8 @@ requirements are added.
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>, Univ.of Notre Dame (<A HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
 </TD></TR></TABLE>
 
 </BODY>

doc/VertexListGraph.html

@@ -1,20 +1,16 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  Silicon Graphics makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>VertexListGraph</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -24,18 +20,24 @@
 VertexListGraph
 </H2>
 
-The VertexListGraph</I> concept refines the <a
-href="./AdjacencyGraph.html">AdjacencyGraph</a> concept, and adds the
-requirement for efficient traversal of all the vertices in the graph.
+The <I>VertexListGraph</I> concept refines the <a
+href="./Graph.html">Graph</a> concept, and adds the requirement for
+efficient traversal of all the vertices in the graph.
 
 <H3>Refinement of</H3>
 
-<a href="./AdjacencyGraph.html">AdjacencyGraph</a>
+<a href="./Graph.html">Graph</a>
 
 <H3>Associated Types</H3>
 
 <Table border>
 
+<tr>
+<td><tt>boost::graph_traits&lt;G&gt;::traversal_category</tt><br><br>
+ This tag type must be convertible to <tt>vertex_list_graph_tag</tt>.
+</td>
+</tr>
+
 <TR>
 <TD><tt>boost::graph_traits&lt;G&gt;::vertex_iterator</tt><br><br>
 A vertex iterator (obtained via <TT>vertices(g)</TT>) provides access
@@ -94,18 +96,34 @@ The <TT>vertices()</TT> function must return in constant time.
 <a href="./graph_concepts.html">Graph concepts</a>
 
 
+<H3>Design Rationale</H3>
+
+One issue in the design of this concept is whether to include the
+refinement from the <a href="./IncidenceGraph.html">IncidenceGraph</a>
+and <a href="./AdjacencyGraph.html">AdjacencyGraph</a> concepts.  The
+ability to traverse the vertices of a graph is orthogonal to
+traversing out-edges, so it would make sense to have a VertexListGraph
+concept that only includes vertex traversal. However, such a concept
+would no longer really be a graph, but would just be a set, and the
+STL already has concepts for dealing with such things. However, there
+are many BGL algorithms that need to traverse the vertices and
+out-edges of a graph, so for convenience a concept is needed that
+groups these requirements together, hence the VertexListGraph concept.
+
+
 <H3>Concept Checking Class</H3>
 
 <P>
 <PRE>
   template &lt;class G&gt;
-  struct VertexListGraph_concept
+  struct VertexListGraphConcept
   {
     typedef typename boost::graph_traits&lt;G&gt;::vertex_iterator 
       vertex_iterator;
     void constraints() {
-      REQUIRE(G, AdjacencyGraph);
-      REQUIRE(vertex_iterator, MultiPassInputIterator);
+      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept&lt;vertex_iterator&gt; ));
 
       p = vertices(g);
       V = num_vertices(g);
@@ -128,8 +146,8 @@ The <TT>vertices()</TT> function must return in constant time.
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>, Univ.of Notre Dame (<A HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
 </TD></TR></TABLE>
 
 </BODY>

doc/VertexMutableGraph.html

@@ -0,0 +1,83 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek 2001
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Vertex Mutable Graph</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H2><A NAME="concept:VertexMutableGraph">
+Vertex Mutable Graph
+</H2>
+
+A vertex mutable graph can be changed by adding or removing
+vertices. The memory management is the responsibility of the graph
+implementation. The graph user need only make calls to
+<TT>add_vertex</TT> and <TT>remove_vertex</TT> and the graph
+implementation does the rest.
+
+<H3>Refinement of</H3>
+
+<a href="./Graph.html">Graph</a> and <a
+href="http://www.boost.org/sgi/stl/DefaultConstructible.html">DefaultConstructible</a>
+
+<H3>Associated Types</H3>
+
+No additional associated types.
+
+<h3>Valid Expressions</h3>
+
+<ul>
+<li><a name="sec:add_vertex"><TT>add_vertex(g)</TT></a> 
+<b>returns</b> <TT>vertex_descriptor</TT>
+<br><br>
+
+<b>Semantics:</b>  Add a new vertex to the graph. The
+        <TT>vertex_descriptor</TT> for the new vertex is returned.<br>
+</li>
+
+<li><a name="sec:remove_vertex"><tt>remove_vertex(u, g)</tt></a>
+<b>returns</b> <tt>void</tt><br><br>
+
+<b> Semantics:</b>  Remove <i>u</i> from the vertex set of the graph.
+<br>
+<b> Preconditions:</b> <i>u</i> is a valid vertex descriptor of graph <i>g</i>
+     and there are no edges incident to vertex <i>u</i>. The function
+     <TT>clear_vertex</TT> can be used to remove all incident edges.
+<br>
+<b> Postconditions: </b> <TT>num_vertices(g)</TT> is one less; <i>u</i>
+      no longer appears in the vertex set of the graph and it
+      is no longer a valid vertex descriptor. 
+</li>
+
+</ul>
+
+<H3>Complexity guarantees</H3>
+<ul>
+  <li> Vertex insertion is guaranteed to be amortized constant time.
+ 
+  <li> Vertex removal is at most <TT>O(|E| + |V|)</TT>.
+</ul>
+
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 
+

doc/acknowledgements.html

@@ -1,20 +1,16 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  We make no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>Boost Graph Library: Acknowledgements</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -66,14 +62,14 @@ Science of the U.S. Department of Energy.
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~llee1>Lie-Quan Lee</A>, Univ.of Notre Dame (<A HREF="mailto:llee1@lsc.nd.edu">llee1@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~lums>Andrew Lumsdaine</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:lums@lsc.nd.edu">lums@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
 
 </BODY>

doc/adjacency_iterator.html

@@ -0,0 +1,136 @@
+<html>
+<!--
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
+<meta name="GENERATOR" content="Microsoft FrontPage 4.0">
+<meta name="ProgId" content="FrontPage.Editor.Document">
+<title>Adjacency Iterator Adaptor Documentation</title>
+</head>
+
+<body bgcolor="#FFFFFF" text="#000000">
+
+<img src="../../../boost.png" alt="boost.png (6897 bytes)"
+align="center" width="277" height="86">
+
+<h1>Adjacency Iterator Adaptor</h1>
+
+Defined in header
+<a href="../../../boost/graph/adjacency_iterator.hpp">boost/graph/adjacency_iterator.hpp</a>
+
+<p>
+The adjacency iterator adaptor transforms an
+<tt>out_edge_iterator</tt> into an adjacency iterator. That is, it
+takes an iterator that traverses over edges, and creates an iterator
+that traverses over the <b><i>target</i></b> vertices of those edges.
+With this adaptor it is trivial to take a graph type that models <a
+href="IncidenceGraph.html">Incidence Graph</a> and add the
+capabilities required of <a href="AdjacencyGraph.html">Adjacency
+Graph</a>.
+
+
+<h2>Synopsis</h2>
+
+<pre>
+namespace boost {
+  template &lt;class Graph, class VertexDescriptor, class OutEdgeIter&gt;
+  class adjacency_iterator_generator {
+  public:
+    typedef <a href="../../iterator/doc/iterator_adaptor.html">iterator_adaptor</a>&lt;...&gt; type;
+  };
+}
+</pre>
+
+<hr>
+
+<h3>Example</h3>
+
+<p>
+The following is an example of how to use the
+<tt>adjacency_iterator_generator</tt> class.
+
+<p>
+<PRE>
+#include &lt;boost/graph/adjacency_iterator.hpp&gt;
+
+class my_graph {
+  // ...
+  typedef ... out_edge_iterator;
+  typedef ... vertex_descriptor;
+  typedef boost::adjacency_iterator_generator&lt;my_graph, vertex_descriptor, out_edge_iterator&gt;::type adjacency_iterator;
+  // ...
+};
+
+</PRE>
+
+<h3>Template Parameters</h3>
+
+<Table border>
+<TR>
+<TH>Parameter</TH><TH>Description</TH>
+</TR>
+
+<TR>
+<TD><tt>Graph</tt></TD>
+<TD>The graph type, which must model <a
+href="./IncidenceGraph.html">Incidence Graph</a>.</TD>
+</TR>
+
+<TR>
+<TD><tt>VertexDescriptor</tt></TD>
+<TD>This must be the same type as
+<tt>graph_traits&lt;Graph&gt;::vertex_descriptor</tt>.  The reason why
+this is a template parameter is that the primary use of
+<tt>adjacency_iterator_generator</tt> is <b><i>inside</i></b> the
+definition of the graph class, and in that context we can not use
+<tt>graph_traits</tt> on the not yet fully defined graph class.<br>
+<b>Default:</b> <tt>graph_traits&lt;Graph&gt;::vertex_descriptor</tt></TD>
+</TR>
+
+<TR>
+<TD><tt>OutEdgeIter</tt></TD>
+<TD>This must be the same type as
+<tt>graph_traits&lt;Graph&gt;::out_edge_iterator</tt>.<br>
+<b>Default:</b> <tt>graph_traits&lt;Graph&gt;::out_edge_iterator
+</TD>
+</TR>
+
+</Table>
+
+<h3>Model of</h3>
+
+The adjacency iterator adaptor (the type
+<tt>adjacency_iterator_generator<...>::type</tt>) is a model of <a
+href="../../utility/MultiPassInputIterator.html">Multi-Pass Input Iterator</a>
+</a>.
+
+
+<h3>Members</h3>
+
+The adjacency iterator type implements the member functions and
+operators required of the <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:
+
+<pre>
+adjacency_iterator_generator::type(const OutEdgeIter&amp; it, const Graph* g)
+</pre>
+
+<hr>
+<p>Revised <!--webbot bot="Timestamp" s-type="EDITED" s-format="%d %b %Y" startspan -->19 Aug 2001<!--webbot bot="Timestamp" endspan i-checksum="14767" --></p>
+<p>© Copyright Jeremy Siek 2000. Permission to copy, use,
+modify, sell and distribute this document is granted provided this copyright
+notice appears in all copies. This document is provided &quot;as is&quot;
+without express or implied warranty, and with no claim as to its suitability for
+any purpose.</p>
+
+</body>
+
+</html>

doc/adjacency_list_traits.html

@@ -1,20 +1,16 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  We make no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>Boost Graph Library: Graph Traits</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -83,8 +79,8 @@ The selector type whether the graph is directed or undirected.
 <h3>Model of</h3>
 
 <a
-href="http://www.sgi.com/Technology/STL/DefaultConstructible.html">DefaultConstructible</a> and
-<a href="http://www.sgi.com/Technology/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>
 
@@ -148,14 +144,14 @@ parallel edges (<tt>disallow_parallel_edge_tag</tt>).
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~llee1>Lie-Quan Lee</A>, Univ.of Notre Dame (<A HREF="mailto:llee1@lsc.nd.edu">llee1@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~lums>Andrew Lumsdaine</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:lums@lsc.nd.edu">lums@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
 
 </BODY>

doc/adjacency_matrix.html

@@ -0,0 +1,584 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Adjacency Matrix</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><A NAME="sec:adjacency-matrix-class"></A>
+<pre>
+adjacency_matrix&lt;Directed, VertexProperty, 
+                 EdgeProperty, GraphProperty,
+                 Allocator&gt;
+</pre>
+</H1>
+
+The <tt>adjacency_matrix</tt> class implements the BGL graph interface
+using the traditional adjacency matrix storage format. For a graph
+with <i>V</i> vertices, a <i>V x V</i> matrix is used, where each
+element <i>a<sub>ij</sub></i> is a boolean flag that says whether
+there is an edge from vertex <i>i</i> to vertex <i>j</i>. <a
+href="#fig:adj-matrix-graph">Figure 1</a> shows the adjacency matrix
+representation of a graph.
+
+<P></P>
+<DIV ALIGN="center"><A NAME="fig:adj-matrix-graph"></A>
+<TABLE>
+<CAPTION ALIGN="BOTTOM"><STRONG>Figure 1:</STRONG> Adjacency Matrix Representation of a Directed Graph.</CAPTION>
+<TR><TD><IMG SRC="./figs/adj-matrix-graph3.gif" width="386" height="284"></TD>
+<TD><IMG SRC="./figs/adj-matrix.gif" width="135" height="136"></TD></TR>
+</TABLE>
+</DIV><P></P>
+
+The advantage of this matrix format over the adjacency list is that
+edge insertion and removal is constant time.  There are several
+disadvantages. The first is that the amount of memory used is
+<i>O(V<sup>2</sup>)</i> instead of <i>O(V + E)</i> (where <i>E</i> is
+the number of edges). The second is that operations that traverse all
+the out-edges of each vertex (such as breadth-first search) run in
+<i>O(V<sup>2</sup>)</i> time instead of <i>O(V + E)</i> time for the
+adjacency list. In short, it is better to use the
+<tt>adjacency_matrix</tt> for dense graphs (where <i>E</i> is close to
+<i>V<sup>2</sup></i>) and it is better to use <a
+href="adjacency_list.html"><tt>adjacency_list</tt></a> for sparse
+graphs (where <i>E</i> is much smaller than <i>V<sup>2</sup></i>).
+
+The <tt>adjacency_matrix</tt> class extends the traditional
+data-structure by allowing objects to be attached to vertices and
+edges using the same property template parameters supported by <a
+href="adjacency_list.html"><tt>adjacency_list</tt></a>. These may be
+<a href="bundles.html">bundled properties</a> or standard (backward-compatible)
+<a
+href="using_adjacency_list.html#sec:adjacency-list-properties">interior
+properties</a>. The types of all property values must be
+Copy Constructible, Assignable and Default Constructible. 
+
+In the case of an undirected graph, the
+<tt>adjacency_matrix</tt>. class does not use a full <i>V x V</i>
+matrix but instead uses a lower triangle (the diagonal and below)
+since the matrix for an undirected graph is symmetric. This reduces
+the storage to <i>(V<sup>2</sup>)/2</i>.  <a
+href="#fig:undir-adj-matrix-graph">Figure 2</a> shows an adjacency
+matrix representation of an undirected graph.
+
+<P></P>
+<DIV ALIGN="center"><A NAME="fig:undir-adj-matrix-graph"></A>
+<TABLE>
+<CAPTION ALIGN="BOTTOM"><STRONG>Figure 2:</STRONG> Adjacency Matrix Representation of an Undirected Graph.</CAPTION>
+<TR><TD><IMG SRC="./figs/undir-adj-matrix-graph3.gif" width="260" height="240"></TD>
+<TD><IMG SRC="./figs/undir-adj-matrix2.gif" width="135" height="136"></TD></TR>
+</TABLE>
+</DIV><P></P>
+
+
+<h3>Example</h3>
+
+Creating the graph of <a href="#fig:adj-matrix-graph">Figure 1</a>. 
+<pre>
+  enum { A, B, C, D, E, F, N };
+  const char* name = "ABCDEF";
+  
+  typedef boost::adjacency_matrix&lt;boost::directedS> Graph;
+  Graph g(N);
+  add_edge(B, C, g);
+  add_edge(B, F, g);
+  add_edge(C, A, g);
+  add_edge(C, C, g);
+  add_edge(D, E, g);
+  add_edge(E, D, g);
+  add_edge(F, A, g);
+
+  std::cout &lt;&lt; "vertex set: ";
+  boost::print_vertices(g, name);
+  std::cout &lt;&lt; std::endl;
+
+  std::cout &lt;&lt; "edge set: ";
+  boost::print_edges(g, name);
+  std::cout &lt;&lt; std::endl;
+
+  std::cout &lt;&lt; "out-edges: " &lt;&lt; std::endl;
+  boost::print_graph(g, name);
+  std::cout &lt;&lt; std::endl;
+</pre>
+The output is:
+<pre>
+  vertex set: A B C D E F 
+
+  edge set: (B,C) (B,F) (C,A) (C,C) (D,E) (E,D) (F,A) 
+
+  out-edges: 
+  A --> 
+  B --> C F 
+  C --> A C 
+  D --> E 
+  E --> D 
+  F --> A 
+</pre>
+
+Creating the graph of <a href="#fig:undir-adj-matrix-graph">Figure 2</a>.
+<pre>
+  enum { A, B, C, D, E, F, N };
+  const char* name = "ABCDEF";
+
+  typedef boost::adjacency_matrix&lt;boost::undirectedS> UGraph;
+  UGraph ug(N);
+  add_edge(B, C, ug);
+  add_edge(B, F, ug);
+  add_edge(C, A, ug);
+  add_edge(D, E, ug);
+  add_edge(F, A, ug);
+
+  std::cout &lt;&lt; "vertex set: ";
+  boost::print_vertices(ug, name);
+  std::cout &lt;&lt; std::endl;
+
+  std::cout &lt;&lt; "edge set: ";
+  boost::print_edges(ug, name);
+  std::cout &lt;&lt; std::endl;
+
+  std::cout &lt;&lt; "incident edges: " &lt;&lt; std::endl;
+  boost::print_graph(ug, name);
+  std::cout &lt;&lt; std::endl;
+</pre>
+The output is:
+<pre>
+  vertex set: A B C D E F 
+
+  edge set: (C,A) (C,B) (E,D) (F,A) (F,B) 
+
+  incident edges: 
+  A &lt;--> C F 
+  B &lt;--> C F 
+  C &lt;--> A B 
+  D &lt;--> E 
+  E &lt;--> D 
+  F &lt;--> A B 
+</pre>
+
+
+<h3>Where Defined</h3>
+
+<a href="../../../boost/graph/adjacency_matrix.hpp"><tt>boost/graph/adjacency_matrix.hpp</tt></a>
+
+
+<h3>Template Parameters</h3>
+
+<p>
+<table border>
+
+<TR>
+<th>Parameter</th><th>Description</th><th>Default</th>
+</tr>
+
+<tr>
+  <td><tt>Directed</tt></td>
+  <td>A selector to choose whether the graph is directed or undirected. The options are <tt>directedS</tt> and <tt>undirectedS</tt>.</td>
+  <td><tt>directedS</tt></td>
+</tr>
+<tr>
+  <td><tt>VertexProperty</tt></td>
+  <td>for specifying internal property storage.</td>
+  <td><tt>no_property</tt></td>
+</tr>
+<tr>
+  <td><tt>EdgeProperty</tt></td>
+  <td>for specifying internal property storage.</td>
+  <td><tt>no_property</tt></td>
+</tr>
+<tr>
+  <td><tt>GraphProperty</tt></td>
+  <td>for specifying property storage for the graph object.</td>
+  <td><tt>no_property</tt></td>
+</tr>
+
+</table>
+
+<h3>Model Of</h3>
+
+<a href="./VertexAndEdgeListGraph.html">VertexAndEdgeListGraph</a>, 
+<a href="./IncidenceGraph.html">Incidence Graph</a>,
+<a href="./BidirectionalGraph.html">Bidirectional Graph</a>,
+<a
+href="./AdjacencyMatrix.html">AdjacencyMatrix</a>, <a
+href="./MutablePropertyGraph.html">MutablePropertyGraph</a>,
+<a href="../../utility/CopyConstructible.html">CopyConstructible</a>,
+and <a href="../../utility/Assignable.html">Assignable</a>.
+
+
+<h3>Associated Types</h3>
+
+<hr>
+
+<tt>graph_traits&lt;adjacency_matrix&gt;::vertex_descriptor</tt>
+<br><br>
+The type for the vertex descriptors associated with the
+<tt>adjacency_matrix</tt>.<br>
+(Required by <a href="./Graph.html">Graph</a>.)
+
+<hr>
+
+<tt>graph_traits&lt;adjacency_matrix&gt;::edge_descriptor</tt>
+<br><br>
+The type for the edge descriptors associated with the
+  <tt>adjacency_matrix</tt>.<br>
+ (Required by <a href="Graph.html">Graph</a>.)
+
+<hr>
+<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.boost.org/sgi/stl/RandomAccessIterator.html">RandomAccessIterator</a>. <br>
+ (Required by <a href="VertexListGraph.html">VertexListGraph</a>.)
+
+<hr>
+<tt>graph_traits&lt;adjacency_matrix&gt;::edge_iterator</tt>
+<br><br>
+  The type for the iterators returned by <tt>edges()</tt>. This
+  iterator models <a href="../../utility/MultiPassInputIterator.html">MultiPassInputIterator</a>.<br>
+ (Required by <a href="EdgeListGraph.html">EdgeListGraph</a>.)
+
+<hr>
+<tt>graph_traits&lt;adjacency_matrix&gt;::out_edge_iterator</tt>
+<br><br>
+  The type for the iterators returned by <tt>out_edges()</tt>.  This
+  iterator models <a href="../../utility/MultiPassInputIterator.html">MultiPassInputIterator</a>. <br>
+  (Required by <a href="IncidenceGraph.html">IncidenceGraph</a>.)
+
+<hr>
+<tt>graph_traits&lt;adjacency_matrix&gt;::in_edge_iterator</tt>
+<br><br>
+  The type for the iterators returned by <tt>in_edges()</tt>.  This
+  iterator models <a href="../../utility/MultiPassInputIterator.html">MultiPassInputIterator</a>. <br>
+  (Required by <a href="BidirectionalGraph.html">BidirectionalGraph</a>.)
+
+<hr>
+<tt>graph_traits&lt;adjacency_matrix&gt;::adjacency_iterator</tt>
+<br><br>
+  The type for the iterators returned by <tt>adjacent_vertices()</tt>. This
+  iterator models the same concept as the out-edge iterator.<br>
+  (Required by <a href="AdjacencyGraph.html">AdjacencyGraph</a>.)
+
+<hr>
+<tt>graph_traits&lt;adjacency_matrix&gt;::directed_category</tt>
+<br><br>
+  Provides information about whether the graph is directed
+  (<tt>directed_tag</tt>) or undirected (<tt>undirected_tag</tt>).<br>
+  (Required by <a href="Graph.html">Graph</a>.)
+
+<hr>
+<tt>graph_traits&lt;adjacency_matrix&gt;::edge_parallel_category</tt>
+<br><br>
+  An adjacency matrix does not allow the insertion of
+  parallel edges, so this type is always
+  <tt>disallow_parallel_edge_tag</tt>. <br>
+  (Required by <a href="Graph.html">Graph</a>.)
+
+<hr>
+<tt>graph_traits&lt;adjacency_matrix&gt;::vertices_size_type</tt>
+<br><br>
+  The type used for dealing with the number of vertices in
+  the graph.<br>
+  (Required by <a href="VertexListGraph.html">VertexListGraph</a>.)
+
+<hr>
+<tt>graph_traits&lt;adjacency_matrix&gt;::edges_size_type</tt>
+<br><br>
+  The type used for dealing with the number of edges in the graph.<br>
+  (Required by <a href="EdgeListGraph.html">EdgeListGraph</a>.)
+
+<hr>
+<tt>graph_traits&lt;adjacency_matrix&gt;::degree_size_type</tt>
+<br><br>
+  The type used for dealing with the number of out-edges of a vertex.<br>
+  (Required by <a href="IncidenceGraph.html">IncidenceGraph</a>.)
+
+<hr>
+<tt>property_map&lt;adjacency_matrix, PropertyTag&gt;::type</tt><br>
+<tt>property_map&lt;adjacency_matrix, PropertyTag&gt;::const_type</tt>
+<br><br>
+  The map type for vertex or edge properties in the graph. The
+  specific property is specified by the <tt>PropertyTag</tt> template
+  argument, and must match one of the properties specified in the
+  <tt>VertexProperty</tt> or <tt>EdgeProperty</tt> for the graph.<br>
+  (Required by <a href="PropertyGraph.html">PropertyGraph</a>.)
+
+<hr>
+
+<h3>Member Functions</h3>
+
+<hr>
+<pre>
+adjacency_matrix(vertices_size_type n,
+                 const GraphProperty& p = GraphProperty())
+</pre>
+Creates a graph object with <tt>n</tt> vertices and zero edges.<br>
+(Required by <a href="MutableGraph.html">MutableGraph</a>.)
+
+<hr>
+<pre>
+template &lt;typename EdgeIterator&gt;
+adjacency_matrix(EdgeIterator first,
+                 EdgeIterator last,
+                 vertices_size_type n,
+                 const GraphProperty& p = GraphProperty())
+</pre>
+  Creates a graph object with <tt>n</tt> vertices with the edges
+  specified in the edge list given by the range <tt>[first, last)</tt>.
+  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
+  range of
+  <tt>[0, n)</tt>. <br>
+  (Required by <a href="IteratorConstructibleGraph.html">IteratorConstructibleGraph</a>.)
+
+<hr>
+<pre>
+template &lt;typename EdgeIterator, typename EdgePropertyIterator&gt;
+adjacency_matrix(EdgeIterator first, EdgeIterator last,
+                 EdgePropertyIterator ep_iter,
+                 vertices_size_type n,
+                 const GraphProperty& p = GraphProperty())
+</pre>
+  Creates a graph object with <tt>n</tt> vertices, with the edges
+  specified in the edge list given by the range <tt>[first, last)</tt>.
+  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
+  range of <tt>[0, n)</tt>. The <tt>value_type</tt> of the
+  <tt>ep_iter</tt> should be <tt>EdgeProperty</tt>.
+
+<hr>
+
+
+<h3>Non-Member Functions</h3>
+
+<hr>
+<pre>
+std::pair&lt;vertex_iterator, vertex_iterator&gt;
+vertices(const adjacency_matrix&amp; g)
+</pre>
+Returns an iterator-range providing access to the vertex set of graph <tt>g</tt>.<br>
+(Required by <a href="VertexListGraph.html">VertexListGraph</a>.)
+
+<hr>
+<pre>
+std::pair&lt;edge_iterator, edge_iterator&gt;
+edges(const adjacency_matrix&amp; g);
+</pre>
+Returns an iterator-range providing access to the edge set of graph <tt>g</tt>.<br>
+(Required by <a href="EdgeListGraph.html">EdgeListGraph</a>.)
+
+<hr>
+<pre>
+std::pair&lt;adjacency_iterator, adjacency_iterator&gt;
+adjacent_vertices(vertex_descriptor v, const adjacency_matrix&amp; g)
+</pre>
+Returns an iterator-range providing access to the vertices adjacent to
+vertex <tt>v</tt> in graph <tt>g</tt>.<br>
+(Required by <a href="AdjacencyGraph.html">AdjacencyGraph</a>.)
+
+<hr>
+<pre>
+std::pair&lt;out_edge_iterator, out_edge_iterator&gt;
+out_edges(vertex_descriptor v, const adjacency_matrix&amp; g)
+</pre>
+Returns an iterator-range providing access to the out-edges of
+vertex <tt>v</tt> in graph <tt>g</tt>. If the graph is undirected,
+this iterator-range provides access to all edges incident on
+vertex <tt>v</tt>. <br>
+(Required by <a href="IncidenceGraph.html">IncidenceGraph</a>.)
+
+<hr>
+<pre>
+vertex_descriptor
+source(edge_descriptor e, const adjacency_matrix&amp; g)
+</pre>
+Returns the source vertex of edge <tt>e</tt>.<br>
+(Required by <a href="IncidenceGraph.html">IncidenceGraph</a>.)
+
+<hr>
+<pre>
+vertex_descriptor
+target(edge_descriptor e, const adjacency_matrix&amp; g)
+</pre>
+Returns the target vertex of edge <tt>e</tt>.<br>
+(Required by <a href="IncidenceGraph.html">IncidenceGraph</a>.)
+
+<hr>
+<pre>
+degree_size_type
+out_degree(vertex_descriptor u, const adjacency_matrix&amp; g)
+</pre>
+Returns the number of edges leaving vertex <tt>u</tt>.<br>
+(Required by <a href="IncidenceGraph.html">IncidenceGraph</a>.) 
+<hr>
+
+<hr>
+<pre>
+std::pair&lt;in_edge_iterator, in_edge_iterator&gt;
+in_edges(vertex_descriptor v, const adjacency_matrix&amp; g)
+</pre>
+Returns an iterator-range providing access to the in-edges of
+vertex <tt>v</tt> in graph <tt>g</tt>. If the graph is undirected,
+this iterator-range provides access to all edges incident on
+vertex <tt>v</tt>. <br>
+(Required by <a href="BidirectionalGraph.html">BidirectionalGraph</a>.)
+
+<hr>
+<pre>
+degree_size_type
+in_degree(vertex_descriptor u, const adjacency_matrix&amp; g)
+</pre>
+Returns the number of edges entering vertex <tt>u</tt>.<br>
+(Required by <a href="BidirectionalGraph.html">BidirectionalGraph</a>.) 
+<hr>
+
+<hr>
+<pre>
+vertices_size_type num_vertices(const adjacency_matrix&amp; g)
+</pre>
+Returns the number of vertices in the graph <tt>g</tt>.<br>
+(Required by <a href="VertexListGraph.html">VertexListGraph</a>.)
+
+<hr>
+<pre>
+edges_size_type num_edges(const adjacency_matrix&amp; g)
+</pre>
+Returns the number of edges in the graph <tt>g</tt>.<br>
+(Required by <a href="EdgeListGraph.html">EdgeListGraph</a>.)
+
+<hr>
+<pre>
+vertex_descriptor vertex(vertices_size_type n, const adjacency_matrix&amp; g)
+</pre>
+Returns the nth vertex in the graph's vertex list.
+
+<hr>
+<pre>
+std::pair&lt;edge_descriptor, bool&gt;
+edge(vertex_descriptor u, vertex_descriptor v,
+     const adjacency_matrix&amp; g)
+</pre>
+Returns the edge connecting vertex <tt>u</tt> to vertex <tt>v</tt> in graph <tt>g</tt>.<br>
+(Required by <a href="AdjacencyMatrix.html">AdjacencyMatrix</a>.)
+
+<hr>
+<pre>
+std::pair&lt;edge_descriptor, bool&gt;
+add_edge(vertex_descriptor u, vertex_descriptor v,
+         adjacency_matrix&amp; g)
+</pre>
+  Adds edge <tt>(u,v)</tt> to the graph and returns the edge descriptor for
+  the new edge. If the edge is already in the graph then a duplicate
+  will not be added and the <tt>bool</tt> flag will be <tt>false</tt>.
+  This operation does not invalidate any of the graph's iterators
+  or descriptors.<br>
+(Required by <a href="MutableGraph.html">MutableGraph</a>.)
+
+<hr>
+<pre>
+std::pair&lt;edge_descriptor, bool&gt;
+add_edge(vertex_descriptor u, vertex_descriptor v,
+         const EdgeProperty& p,
+         adjacency_matrix&amp; g)
+</pre>
+Adds edge <tt>(u,v)</tt> to the graph and attaches <tt>p</tt> as the
+value of the edge's internal property storage.  Also see the previous
+<tt>add_edge()</tt> member function for more details.
+
+<hr>
+<pre>
+void remove_edge(vertex_descriptor u, vertex_descriptor v,
+                 adjacency_matrix&amp; g)
+</pre>
+Removes the edge <tt>(u,v)</tt> from the graph.  <br>
+(Required by <a href="MutableGraph.html">MutableGraph</a>.)
+
+<hr>
+<pre>
+void remove_edge(edge_descriptor e, adjacency_matrix&amp; g)
+</pre>
+Removes the edge <tt>e</tt> from the graph. This is equivalent
+to calling <tt>remove_edge(source(e, g), target(e, g), g)</tt>.<br>
+(Required by <a href="MutableGraph.html">MutableGraph</a>.)
+
+<hr>
+<pre>
+void clear_vertex(vertex_descriptor u, adjacency_matrix&amp; g)
+</pre>
+Removes all edges to and from vertex <tt>u</tt>. The vertex still appears
+in the vertex set of the graph.<br>
+(Required by <a href="MutableGraph.html">MutableGraph</a>.)
+
+<hr>
+<pre>
+template &lt;typename Property&gt;
+property_map&lt;adjacency_matrix, Property&gt;::type
+get(Property, adjacency_matrix&amp; g)
+
+template &lt;typename Property&gt;
+property_map&lt;adjacency_matrix, Property&gt;::const_type
+get(Property, const adjacency_matrix&amp; g)
+</pre>
+Returns the property map object for the vertex property specified by
+<tt>Property</tt>. The <tt>Property</tt> must match one of the
+properties specified in the graph's <tt>VertexProperty</tt> template
+argument.<br>
+(Required by <a href="PropertyGraph.html">PropertyGraph</a>.)
+
+<hr>
+<pre>
+template &lt;typename Property, typename X&gt;
+typename property_traits&lt;
+  typename property_map&lt;adjacency_matrix, Property&gt;::const_type
+&gt;::value_type
+get(Property, const adjacency_matrix&amp; g, X x)
+</pre>
+This returns the property value for <tt>x</tt>, which is either
+a vertex or edge descriptor.<br>
+(Required by <a href="PropertyGraph.html">PropertyGraph</a>.)
+
+<hr>
+<pre>
+template &lt;typename Property, typename X, typename Value&gt;
+void
+put(Property, const adjacency_matrix&amp; g, X x, const Value& value)
+</pre>
+This sets the property value for <tt>x</tt> to
+<tt>value</tt>. <tt>x</tt> is either a vertex or edge descriptor.
+<tt>Value</tt> must be convertible to
+<tt>typename property_traits&lt;property_map&lt;adjacency_matrix, Property&gt;::type&gt;::value_type</tt>.<br>
+(Required by <a href="PropertyGraph.html">PropertyGraph</a>.)
+
+<hr>
+<pre>
+template &lt;typename GraphProperty, typename GraphProperty&gt;
+typename property_value&lt;GraphProperty, GraphProperty&gt;::type&amp;
+get_property(adjacency_matrix&amp; g, GraphProperty)
+</pre>
+Return the property specified by <tt>GraphProperty</tt> that is attached
+to the graph object <tt>g</tt>. The <tt>property_value</tt> traits class
+is defined in <tt>boost/pending/property.hpp</tt>.
+
+<hr>
+<pre>
+template &lt;typename GraphProperty, typename GraphProperty&gt;
+const typename property_value&lt;GraphProperty, GraphProperty&gt;::type&amp;
+get_property(const adjacency_matrix&amp; g, GraphProperty)
+</pre>
+Return the property specified by <tt>GraphProperty</tt> that is
+attached to the graph object <tt>g</tt>.  The <tt>property_value</tt>
+traits class is defined in <tt>boost/pending/property.hpp</tt>.
+
+
+<hr>

doc/astar_heuristic.html

@@ -0,0 +1,96 @@
+<HTML>
+<!--
+     Copyright (c) 2004 Kris Beevers
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: astar_heuristic</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1>
+<pre>
+astar_heuristic&lt;Graph, CostType&gt;
+</pre>
+</H1>
+
+This class is a default implementation of the <a
+href="./AStarHeuristic.html">AStarHeuristic</a> concept.  It
+implements a "zero" heuristic -- a heuristic function that returns a
+cost of zero regardless of the vertex it is passed.
+
+<h3>Model of</h3>
+
+<a href="./AStarHeuristic.html">AStarHeuristic</a>
+
+<H3>Template Parameters</H3>
+
+<P>
+<TABLE border>
+<TR>
+<th>Parameter</th><th>Description</th><th>Default</th>
+</tr>
+
+<TR><TD><TT>Graph</TT></TD>
+<TD>
+The type of the graph being searched.
+</TD>
+<TD></TD>
+</TR>
+
+<TR><TD><TT>CostType</TT></TD>
+<TD>
+A type that can be used with the <tt>compare</tt> and
+<tt>combine</tt> functions passed to A*.  Typically an integer or
+floating point type.
+</TD>
+<TD></TD>
+</TR>
+
+</table>
+
+<H3>Where Defined</H3>
+
+<P>
+<a href="../../../boost/graph/astar_search.hpp">
+<TT>boost/graph/astar_search.hpp</TT></a>
+
+<h3>Member Functions</h3>
+
+This class implements the single member function required by <a
+href="./AStarHeuristic.html">AStarHeuristic</a>:
+
+<table border>
+<tr>
+<th>Function</th><th>Description</th>
+</tr>
+
+<tr><td><tt>
+CostType operator()(graph_traits&lt;Graph&gt;::vertex_descriptor u);
+</tt></td><td>
+Called for the target of every out edge of a vertex being examined.
+Returns the cost, estimated by the heuristic, from vertex <tt>u</tt>
+to a goal.
+</td></tr>
+
+</table>
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2004</TD><TD>
+<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>
+
+</BODY>
+</HTML> 

doc/astar_search.html

@@ -0,0 +1,589 @@
+<HTML>
+<!--
+     Copyright (c) 2004 Kris Beevers
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: A* Heuristic Search</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><A NAME="sec:astar"></A>
+<TT>astar_search</TT>
+</H1>
+
+
+<P>
+<PRE>
+<i>// Named parameter interfaces</i>
+template &lt;typename VertexListGraph,
+          typename AStarHeuristic,
+          typename P, typename T, typename R&gt;
+void
+astar_search
+  (const VertexListGraph &amp;g,
+   typename graph_traits&lt;VertexListGraph&gt;::vertex_descriptor s,
+   <a href="AStarHeuristic.html">AStarHeuristic</a> h, const bgl_named_params&lt;P, T, R&gt;&amp; params);
+
+template &lt;typename VertexListGraph,
+          typename AStarHeuristic,
+          typename P, typename T, typename R&gt;
+void
+astar_search_no_init
+  (const IncidenceGraph &amp;g,
+   typename graph_traits&lt;VertexListGraph&gt;::vertex_descriptor s,
+   <a href="AStarHeuristic.html">AStarHeuristic</a> h, const bgl_named_params&lt;P, T, R&gt;&amp; params);
+
+template &lt;typename VertexListGraph,
+          typename AStarHeuristic,
+          typename P, typename T, typename R&gt;
+void
+astar_search_tree
+  (const VertexListGraph &amp;g,
+   typename graph_traits&lt;VertexListGraph&gt;::vertex_descriptor s,
+   <a href="AStarHeuristic.html">AStarHeuristic</a> h, const bgl_named_params&lt;P, T, R&gt;&amp; params);
+
+template &lt;typename VertexListGraph,
+          typename AStarHeuristic,
+          typename P, typename T, typename R&gt;
+void
+astar_search_no_init_tree
+  (const IncidenceGraph &amp;g,
+   typename graph_traits&lt;VertexListGraph&gt;::vertex_descriptor s,
+   <a href="AStarHeuristic.html">AStarHeuristic</a> h, const bgl_named_params&lt;P, T, R&gt;&amp; params);
+
+<i>// Non-named parameter interface</i>
+template &lt;typename VertexListGraph, typename AStarHeuristic,
+          typename <a href="AStarVisitor.html">AStarVisitor</a>, typename PredecessorMap,
+          typename CostMap, typename DistanceMap,
+          typename WeightMap, typename VertexIndexMap,
+	  typename ColorMap,
+          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
+  (const VertexListGraph &amp;g,
+   typename graph_traits&lt;VertexListGraph&gt;::vertex_descriptor s,
+   AStarHeuristic h, AStarVisitor vis,
+   PredecessorMap predecessor, CostMap cost,
+   DistanceMap distance, WeightMap weight,
+   VertexIndexMap index_map, ColorMap color,
+   CompareFunction compare, CombineFunction combine,
+   CostInf inf, CostZero zero);
+
+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.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
+  (const VertexListGraph &amp;g,
+   typename graph_traits&lt;VertexListGraph&gt;::vertex_descriptor s,
+   AStarHeuristic h, AStarVisitor vis,
+   PredecessorMap predecessor, CostMap cost,
+   DistanceMap distance, WeightMap weight,
+   CompareFunction compare, CombineFunction combine,
+   CostInf inf, CostZero zero);
+
+<i>// Versions that do not initialize property maps (used for implicit graphs)</i>
+template &lt;typename IncidenceGraph, typename AStarHeuristic,
+          typename <a href="AStarVisitor.html">AStarVisitor</a>, typename PredecessorMap,
+          typename CostMap, typename DistanceMap,
+          typename WeightMap, typename ColorMap,
+          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 CostInf, typename CostZero&gt;
+inline void
+astar_search_no_init
+  (const IncidenceGraph &amp;g,
+   typename graph_traits&lt;IncidenceGraph&gt;::vertex_descriptor s,
+   AStarHeuristic h, AStarVisitor vis,
+   PredecessorMap predecessor, CostMap cost,
+   DistanceMap distance, WeightMap weight,
+   ColorMap color, VertexIndexMap index_map,
+   CompareFunction compare, CombineFunction combine,
+   CostInf inf, CostZero zero);
+
+<b>Note that the index_map and color parameters are swapped in
+astar_search_no_init() relative to astar_search(); the named parameter
+interfaces are not affected.</b>
+
+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.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
+  (const IncidenceGraph &amp;g,
+   typename graph_traits&lt;IncidenceGraph&gt;::vertex_descriptor s,
+   AStarHeuristic h, AStarVisitor vis,
+   PredecessorMap predecessor, CostMap cost,
+   DistanceMap distance, WeightMap weight,
+   CompareFunction compare, CombineFunction combine,
+   CostInf inf, CostZero zero);
+</PRE>
+
+<P>
+This algorithm implements a heuristic search on a weighted, directed
+or undirected graph for the case where all edge weights are
+non-negative.
+</P>
+
+<P>
+The A* algorithm is a <i>heuristic graph search algorithm</i>: an A*
+search is "guided" by a <i>heuristic function</i>.  A heuristic
+function <i>h(v)</i> is one which estimates the cost from a non-goal
+state (<i>v</i>) in the graph to some goal state, <i>g</i>.
+Intuitively, A* follows paths (through the graph) to the goal that are
+estimated by the heuristic function to be the best paths.  Unlike
+best-first search, A* takes into account the known cost from the start
+of the search to <i>v</i>; the paths A* takes are guided by a function
+<i>f(v) = g(v) + h(v)</i>, where <i>h(v)</i> is the heuristic
+function, and <i>g(v)</i> (sometimes denoted <i>c(s, v)</i>) is the
+known cost from the start to <i>v</i>.  Clearly, the efficiency of A*
+is highly dependent on the heuristic function with which it is used.
+</P>
+
+<P>
+The A* algorithm is very similar to Dijkstra's Shortest Paths
+algorithm.  This implementation finds all the shortest paths from the
+start vertex to every other vertex by creating a search tree,
+examining vertices according to their remaining cost to some goal, as
+estimated by a heuristic function.  Most commonly, A* is used to find
+some specific goal vertex or vertices in a graph, after which the
+search is terminated.
+</P>
+
+<P>
+A* is particularly useful for searching <i>implicit</i> graphs.
+Implicit graphs are graphs that are not completely known at the
+beginning of the search.  Upon visiting a vertex, its neighbors are
+"generated" and added to the search.  Implicit graphs are particularly
+useful for searching large state spaces -- in game-playing scenarios
+(e.g. chess), for example -- in which it may not be possible to store
+the entire graph.  Implicit searches can be performed with this
+implementation of A* by creating special visitors that generate
+neighbors of newly-expanded vertices.  Please note that
+<tt>astar_search_no_init()</tt> or <tt>astar_search_no_init_tree()</tt> must be
+used for implicit graphs; the basic
+<tt>astar_search()</tt> function requires a graph that models
+the <a href="VertexListGraph.html">Vertex List Graph</a> concept.  Both
+versions
+also require the graph type to model the <a
+href="IncidenceGraph.html">Incidence Graph</a> concept.
+</P>
+
+<P>
+For the non-tree versions of the algorithm,
+this implementation of A* is based on an OPEN/CLOSED list formulation.
+Vertices on the OPEN list have been ``discovered''
+by the algorithm, but not ``expanded'' (we have not discovered their
+adjacent vertices).  Vertices on the CLOSED list have been completely
+examined by our search (we have expanded them and added their children
+to the OPEN list).  Vertices that are on neither list have not been
+encountered in any context so far in our search.  A major advantage of
+this formulation of the A* algorithm over other approaches is that it
+avoids ``cycles'' in the state space; the search will not become
+trapped by loops in the graph.  The OPEN/CLOSED lists are implemented
+using BGL's vertex coloring mechanisms.  Vertices in OPEN are colored
+gray, vertices in CLOSED are colored black, and undiscovered vertices
+are colored white.  For the versions of the algorithm whose names end in
+<tt>_tree</tt>, all vertices are assumed to always be white, leading to
+checking for repeated vertices being done using the distance map.  If a dummy
+value is used for the distance map and the graph contains cycles, the algorithm
+will probably enter an infinite loop.
+</P>
+
+<P>
+The criteria for expanding a vertex on the OPEN list is that it has
+the lowest <i>f(v) = g(v) + h(v)</i> value of all vertices on OPEN.
+Cost information about vertices is stored in a property map.
+</P>
+
+<P>
+The following is the pseudocode for the A* heuristic search algorithm.
+In the pseudocode, <i>h</i> is the heuristic function, <i>w</i> is the
+edge weight, <i>d</i> is the distance of a vertex from <i>s</i>, and
+<i>Q</i> is a priority queue, sorted by <i>f</i>, the estimated cost
+to the goal of the path through a vertex.  <i>p</i> is a predecessor
+map.  The visitor event points for the algorithm are indicated by the
+labels on the right.
+</P>
+
+<table>
+<tr>
+<td valign="top">
+<pre>
+A*(<i>G</i>, <i>s</i>, <i>h</i>)
+  <b>for</b> each vertex <i>u in V</i>
+    <i>d[u] := f[u] := infinity</i>
+    <i>color[u] :=</i> WHITE
+    <i>p[u] := u</i>
+  <b>end for</b>
+  <i>color[s] :=</i> GRAY
+  <i>d[s] := 0</i>
+  <i>f[s] := h(s)</i>
+  INSERT(<i>Q, s</i>)
+  <b>while</b> (<i>Q != &Oslash;</i>)
+    <i>u :=</i> EXTRACT-MIN(<i>Q</i>)
+    <b>for</b> each vertex <i>v in Adj[u]</i>
+      <b>if</b> (<i>w(u,v) + d[u] &lt; d[v]</i>)
+        <i>d[v] := w(u,v) + d[u]</i>
+	<i>f[v] := d[v] + h(v)</i>
+	<i>p[v] := u</i>
+	<b>if</b> (<i>color[v] =</i> WHITE)
+	  <i>color[v] :=</i> GRAY
+	  INSERT(<i>Q, v</i>)
+	<b>else if</b> (<i>color[v] =</i> BLACK)
+	  <i>color[v] :=</i> GRAY
+	  INSERT(<i>Q, v</i>)
+	<b>end if</b>
+      <b>else</b>
+        <i>...</i>
+    <b>end for</b>
+    <i>color[u] :=</i> BLACK
+  <b>end while</b>
+</pre>
+</td>
+<td valign="top">
+<pre>
+
+initialize vertex <i>u</i>
+
+
+
+
+
+
+
+discover vertex <i>s</i>
+
+examine vertex <i>u</i>
+examine edge <i>(u,v)</i>
+
+edge <i>(u,v)</i> relaxed
+
+
+
+
+discover vertex <i>v</i>
+
+
+reopen vertex <i>v</i>
+
+
+edge <i>(u,v)</i> not relaxed
+
+finish vertex <i>u</i>
+</pre>
+</td>
+</tr>
+</table>
+
+<h3>Where Defined</h3>
+
+<a href="../../../boost/graph/astar_search.hpp"><tt>boost/graph/astar_search.hpp</tt></a>
+
+<h3>Parameters</h3>
+
+IN: <tt>const VertexListGraph&amp; g</tt>
+<blockquote>
+  The graph object on which the algorithm will be applied for <tt>astar_search()</tt>.  The type
+  <tt>VertexListGraph</tt> must be a model of the <a
+  href="VertexListGraph.html">
+  Vertex List Graph</a> and <a href="IncidenceGraph.html">Incidence Graph</a>
+  concepts.
+</blockquote>
+
+IN: <tt>const IncidenceGraph&amp; g</tt>
+<blockquote>
+  The graph object on which the algorithm will be applied for <tt>astar_search_no_init()</tt>.  The type
+  <tt>IncidenceGraph</tt> must be a model of the 
+  <a href="IncidenceGraph.html">Incidence Graph</a>
+  concept.
+</blockquote>
+
+IN: <tt>vertex_descriptor s</tt>
+<blockquote>
+  The start vertex for the search.  All distances will be calculated
+  from this vertex, and the shortest paths tree (recorded in the
+  predecessor map) will be rooted at this vertex.
+</blockquote>
+
+IN: <tt>AStarHeuristic h</tt>
+<blockquote>
+  The heuristic function that guides the search.  The type
+  <tt>AStarHeuristic</tt> must be a model of the <a href="AStarHeuristic.html">AStarHeuristic</a>
+  concept.
+</blockquote>
+
+<h3>Named Parameters</h3>
+
+IN: <tt>weight_map(WeightMap w_map)</tt>
+<blockquote>
+   The weight or ``length'' of each edge in the graph.  The weights
+   must all be non-negative; the algorithm will throw a <a
+   href="./exception.html#negative_edge"><tt>negative_edge</tt></a>
+   exception if one of the edges is negative.  The type
+   <tt>WeightMap</tt> must be a model of <a
+   href="../../property_map/doc/ReadablePropertyMap.html"><tt>Readable
+   Property Map</tt></a>.  The edge descriptor type of the graph needs
+   to be usable as the key type for the weight map.  The value type
+   for this map must be the same as the value type of the distance
+   map.<br>
+   <b>Default:</b> <tt>get(edge\_weight, g)</tt>
+</blockquote>
+
+IN: <tt>vertex_index_map(VertexIndexMap i_map)</tt>
+<blockquote>
+  This maps each vertex to an integer in the range <tt>[0,
+  num_vertices(g))</tt>.  This is necessary in non-tree versions of the
+  algorithm for efficient updates of
+  the heap data structure when an edge is relaxed.  The type
+  <tt>VertexIndexMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadablePropertyMap.html"><tt>Readable
+  Property Map</tt></a>.  The value type of the map must be an integer
+  type.  The vertex descriptor type of the graph needs to be usable as
+  the key type of the map.<br>
+
+  <b>Default:</b> <tt>get(vertex_index, g)</tt>.
+   Note: if you use this default, make sure your graph has
+   an internal <tt>vertex_index</tt> property. For example,
+   <tt>adjacency_list</tt> with <tt>VertexList=listS</tt> does
+   not have an internal <tt>vertex_index</tt> property.
+</blockquote>
+
+OUT: <tt>predecessor_map(PredecessorMap p_map)</tt>
+<blockquote>
+
+  The predecessor map records the edges in the minimum spanning tree.
+  Upon completion of the algorithm, the edges <tt>(p[u],u)</tt> for
+  all <tt>u</tt> in <tt>V</tt> are in the minimum spanning tree.  If
+  <tt>p[u] = u</tt> then <tt>u</tt> is either the start vertex or a
+  vertex that is not reachable from the start.  The
+  <tt>PredecessorMap</tt> type must be a <a
+  href="../../property_map/doc/ReadWritePropertyMap.html"><tt>Read/Write
+  Property Map</tt></a> with key and vertex types the same as the
+  vertex descriptor type of the graph.<br>
+
+  <b>Default:</b> <tt>dummy_property_map</tt>
+</blockquote>
+
+UTIL/OUT: <tt>distance_map(DistanceMap d_map)</tt>
+<blockquote>
+
+  The shortest path weight from the start vertex <tt>s</tt> to each
+  vertex in the graph <tt>g</tt> is recorded in this property map.
+  The shortest path weight is the sum of the edge weights along the
+  shortest path.  The type <tt>DistanceMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html"><tt>Read/Write
+  Property Map</tt></a>.  The vertex descriptor type of the graph
+  needs to be usable as the key type of the distance map.  The value
+  type of the distance map is the element type of a <a
+  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.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
+  not contain a directed cycle.<br>
+
+  <b>Default:</b> <tt>shared_array_property_map</tt>
+  with the same value type as the
+  <tt>WeightMap</tt>, and of size <tt>num_vertices(g)</tt>, and using
+  the <tt>i_map</tt> for the index map.
+</blockquote>
+
+UTIL/OUT: <tt>rank_map(CostMap c_map)</tt>
+<blockquote>
+
+  The <i>f</i>-value for each vertex.  The <i>f</i>-value is defined
+  as the sum of the cost to get to a vertex from the start vertex, and
+  the estimated cost (as returned by the heuristic function
+  <tt>h</tt>) from the vertex to a goal.  The type <tt>CostMap</tt>
+  must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html"><tt>Read/Write
+  Property Map</tt></a> in non-tree versions of the algorithm, and <a
+  href="../../property_map/doc/WritablePropertyMap.html"><tt>Writable Property
+  Map</tt></a> in tree versions of the algorithm.  The vertex descriptor type
+  of the graph
+  needs to be usable as the key type of the distance map.  The value
+  type of the distance map is the element type of a <a
+  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.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
+  used for this parameter.<br>
+
+  <b>Default:</b> <tt>shared_array_property_map</tt>
+  with the same value type as the
+  <tt>DistanceMap</tt>, and of size <tt>num_vertices(g)</tt>, and using
+  the <tt>i_map</tt> for the index map.
+</blockquote>
+
+UTIL/OUT: <tt>color_map(ColorMap c_map)</tt>
+<blockquote>
+
+  This is used during the execution of non-tree versions of the algorithm to
+  mark the
+  vertices, indicating whether they are on the OPEN or CLOSED lists.
+  The vertices start out white and become gray when they are inserted
+  into the OPEN list.  They then turn black when they are examined and
+  placed on the CLOSED list.  At the end of the algorithm, vertices
+  reachable from the source vertex will have been colored black.  All
+  other vertices will still be white.  The type <tt>ColorMap</tt> must
+  be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html"><tt>Read/Write
+  Property Map</tt></a>.  A vertex descriptor must be usable as the
+  key type of the map, and the value type of the map must be a model
+  of <a href="./ColorValue.html"><tt>Color Value</tt></a>.<br>
+
+  <b>Default:</b> <tt>shared_array_property_map</tt>
+  of value type <tt>default_color_type</tt>, with size
+  <tt>num_vertices(g)</tt>, and using
+  the <tt>i_map</tt> for the index map.
+</blockquote>
+
+IN: <tt>distance_compare(CompareFunction cmp)</tt>
+<blockquote>
+
+  This function is use to compare distances to determine which vertex
+  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.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>
+
+  <b>Default:</b> <tt>std::less&lt;D&gt;</tt> with <tt>D = typename
+  property_traits&lt;DistanceMap&gt;::value_type</tt>.
+</blockquote>
+
+IN: <tt>distance_combine(CombineFunction cmb)</tt>
+<blockquote>
+
+  This function is used to combine distances to compute the distance
+  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.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>
+  property maps).  The result type must be the same type as the
+  distance value type.<br>
+
+  <b>Default:</b> <tt>std::plus&lt;D&gt;</tt> with <tt>D = typename
+  property_traits&lt;DistanceMap&gt;::value_type</tt>.
+</blockquote>
+
+IN: <tt>distance_inf(D inf)</tt>
+<blockquote>
+
+  The <tt>inf</tt> object must be the greatest value of any <tt>D</tt>
+  object.  That is, <tt>compare(d, inf) == true</tt> for any <tt>d !=
+  inf</tt>.  The type <tt>D</tt> is the value type of the
+  <tt>DistanceMap</tt>.<br>
+
+  <b>Default:</b> <tt>std::numeric_limits&lt;D&gt;::max()</tt>
+</blockquote>
+
+IN: <tt>distance_zero(D zero)</tt>
+<blockquote>
+
+  The <tt>zero</tt> value must be the identity element for the <a
+  href="./Monoid.html"><tt>Monoid</tt></a> formed by the distance
+  values and the <tt>combine</tt> function object.  The type
+  <tt>D</tt> is the value type of the <tt>DistanceMap</tt>.<br>
+
+  <b>Default</b>: <tt>D()</tt> with <tt>D = typename
+  property_traits&lt;DistanceMap&gt;::value_type</tt>.
+</blockquote>
+
+OUT: <tt>visitor(AStarVisitor v)</tt>
+<blockquote>
+
+  Use this to specify actions that you would like to happen during
+  certain event points within the algorithm.  The type
+  <tt>AStarVisitor</tt> must be a model of the <a
+  href="AStarVisitor.html"><tt>AStarVisitor</tt></a> concept. The
+  visitor object is passed by value <a href="#1">[1]</a>.<br>
+
+  <b>Default:</b> <tt>astar_visitor&lt;null_visitor&gt;</tt>
+</blockquote>
+
+<H3>Complexity</H3>
+
+<P>
+The time complexity is <i>O((E + V) log V)</i>.
+
+<h3>Visitor Event Points</h3>
+
+<ul>
+<li><b><tt>vis.initialize_vertex(u, g)</tt></b>
+  is invoked on each vertex in the graph before the start of the
+  algorithm.
+<li><b><tt>vis.discover_vertex(v, g)</tt></b>
+  is invoked when a vertex is first discovered and is added to the
+  OPEN list.
+<li><b><tt>vis.examine_vertex(u, g)</tt></b>
+  is invoked when a vertex is popped from
+  the queue (i.e., it has the lowest cost on the OPEN list).
+<li><b><tt>vis.examine_edge(e, g)</tt></b>
+  is invoked on each out-edge of a vertex immediately after it is
+  examined.
+<li><b><tt>vis.edge_relaxed(e, g)</tt></b>
+  is invoked on edge <i>(u,v)</i> if <i>d[u] + w(u,v) &lt; d[v]</i>.
+<li><b><tt>vis.edge_not_relaxed(e, g)</tt></b>
+  is invoked if the edge is not relaxed (see above).
+<li><b><tt>vis.black_target(e, g)</tt></b>
+   is invoked when a vertex that is on the CLOSED list is
+  "rediscovered" via a more efficient path, and is re-added to the
+  OPEN list.
+<li><b><tt>vis.finish_vertex(u, g)</tt></b>
+  is invoked on a vertex when it is added to the CLOSED list, which
+  happens after all of its out edges have been examined.
+</ul>
+
+<H3>Example</H3>
+
+<P>
+See <a href="../example/astar-cities.cpp">
+<TT>example/astar-cities.cpp</TT></a> for an example of
+using A* search.
+
+<H3>Notes</H3>
+
+<a name="1">[1]</a> Since the visitor parameter is passed by value, if
+your visitor contains state then any changes to the state during the
+algorithm will be made to a copy of the visitor object, not the
+visitor object passed in.  Therefore you may want the visitor to hold
+this state by pointer or reference.
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2004</TD><TD>
+<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>
+
+</BODY>
+</HTML> 

doc/astar_visitor.html

@@ -0,0 +1,108 @@
+<HTML>
+<!--
+     Copyright (c) 2004 Kris Beevers
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: astar_visitor</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1>
+<pre>
+astar_visitor&lt;EventVisitorList&gt;
+</pre>
+</H1>
+
+This class is an adapter that converts a list of <a
+href="./EventVisitor.html">EventVisitor</a>'s (constructed using
+<tt>std::pair</tt>) into a <a
+href="./AStarVisitor.html">AStarVisitor</a>.
+
+
+<h3>Example</h3>
+
+See the example for <a href="./EventVisitor.html">EventVisitor</a>.
+
+<h3>Model of</h3>
+
+<a href="./AStarVisitor.html">AStarVisitor</a>
+
+<H3>Template Parameters</H3>
+
+<P>
+<TABLE border>
+<TR>
+<th>Parameter</th><th>Description</th><th>Default</th>
+</tr>
+
+<TR><TD><TT>EventVisitorList</TT></TD>
+<TD>
+A list of <a href="./EventVisitor.html">EventVisitor</a>'s created
+with <tt>std::pair</tt>.
+</TD>
+<TD><TT><a href="./null_visitor.html"><tt>null_visitor</tt></a></TT></TD>
+</TR>
+
+</table>
+
+<H3>Where Defined</H3>
+
+<P>
+<a href="../../../boost/graph/astar_search.hpp">
+<TT>boost/graph/astar_search.hpp</TT></a>
+
+<h3>Member Functions</h3>
+
+This class implements all of the member functions required by <a
+href="./AStarVisitor.html">AStarVisitor</a>. In each function the
+appropriate event is dispatched to the <a
+href="./EventVisitor.html">EventVisitor</a>'s in the
+EventVisitorList.
+
+<h3>Non-Member Functions</h3>
+
+<table border>
+<tr>
+<th>Function</th><th>Description</th>
+</tr>
+
+<tr><td><tt>
+template &lt;class EventVisitorList&gt;<br>
+astar_visitor&lt;EventVisitorList&gt;<br>
+make_astar_visitor(EventVisitorList ev_list);
+</tt></td><td>
+Returns the event visitor list adapted to be an A* visitor.
+</td></tr>
+
+</table>
+
+<h3>See Also</h3>
+
+<a href="./visitor_concepts.html">Visitor concepts</a>
+<p>
+The following are event visitors: <a
+ href="./predecessor_recorder.html"><tt>predecessor_recorder</tt></a>,
+<a href="./distance_recorder.html"><tt>distance_recorder</tt></a>,
+<a href="./time_stamper.html"><tt>time_stamper</tt></a>,
+and <a href="./property_writer.html"><tt>property_writer</tt></a>.
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2004</TD><TD>
+<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>
+
+</BODY>
+</HTML> 

doc/awpaper.sty

@@ -0,0 +1,6 @@
+\DeclareOption{awpaper}
+   {\setlength\paperheight {9.25in}%
+    \setlength\paperwidth  {7.375in}}
+\DeclareOption*{\PassOptonsToPackage{\CurrentOption}{newsiambook}}
+\ProcessOptions
+\ExecuteOptions{awpaper}

doc/bandwidth.html

@@ -0,0 +1,93 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Bandwidth</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><A NAME="sec:bandwidth">
+<TT>bandwidth</TT>
+</H1>
+
+<pre>
+  (1)
+  template &lt;typename Graph&gt;
+  typename graph_traits&lt;Graph&gt;::vertices_size_type
+  bandwidth(const Graph& g)
+
+  (2)
+  template &lt;typename Graph, typename VertexIndexMap&gt;
+  typename graph_traits&lt;Graph&gt;::vertices_size_type
+  bandwidth(const Graph& g, VertexIndexMap index_map)
+</pre>
+
+The <b><i>bandwidth</i></b> of a graph is the maximum
+distance between two adjacent vertices, with distance measured on a
+line upon which the vertices have been placed at unit intervals. To
+put it another way, if the vertices of a graph
+<i>G=(V,E)</i> are each assigned an index from zero to <i>|V| - 1</i>
+given by <i>index[v]</i>, then the bandwidth of <i>G</i> is<br>
+<br>
+<i>B(G) = max { |index[u] - index[v]|&nbsp;&nbsp;| (u,v) in E }</i><br>
+
+
+<h3>Defined in</h3>
+
+<a href="../../../boost/graph/bandwidth.hpp"><tt>boost/graph/bandwidth.hpp</tt></a>
+
+
+<hr>
+
+<H1><A NAME="sec:ith-bandwidth">
+<TT>ith_bandwidth</TT>
+</H1>
+
+<pre>
+  (1)
+  template &lt;typename Graph&gt;
+  typename graph_traits&lt;Graph&gt;::vertices_size_type
+  ith_bandwidth(typename graph_traits&lt;Graph&gt;::vertex_descriptor i,
+		const Graph&amp; g)
+
+  (2)
+  template &lt;typename Graph, typename VertexIndexMap&gt;
+  typename graph_traits&lt;Graph&gt;::vertices_size_type
+  ith_bandwidth(typename graph_traits&lt;Graph&gt;::vertex_descriptor i,
+		const Graph&amp; g,
+		VertexIndexMap index)
+</pre>
+
+The <b><i>i-th bandwidth</i></b> a graph is the maximum distance
+between the <i>i-th</i> vertex and any of its neighbors.<br>
+<br>
+<i>B<sub>i</sub>(G) = max { |index[i] - index[j]|&nbsp;&nbsp;| (i,j) in E }</i><br>
+<br>
+So the bandwidth <i>B(G)</i> can be expressed as the maximum
+of the i-th bandwidths <i>B<sub>i</sub>(G)</i>.<br>
+<br>
+<i>B(G) = max { B<sub>i</sub>(G) &nbsp;&nbsp;| i=0...|V|-1 }</i><br>
+
+<h3>Defined in</h3>
+
+<a href="../../../boost/graph/bandwidth.hpp"><tt>boost/graph/bandwidth.hpp</tt></a>
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 

doc/bc_clustering.html

@@ -0,0 +1,151 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<!--
+     Copyright (c) 2004 Trustees of Indiana University
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<html>
+<head>
+<meta name="generator" content=
+"HTML Tidy for Mac OS X (vers 12 April 2005), see www.w3.org">
+<meta http-equiv="Content-Type" content=
+"text/html; charset=us-ascii">
+<title>Function betweenness_centrality_clustering</title>
+</head>
+<body>
+<div class="titlepage"></div>
+<div class="refnamediv">
+
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86">
+
+<h1><img src="figs/python.gif" alt="(Python)"/><span class="refentrytitle">Function
+betweenness_centrality_clustering</span></h1>
+<p>boost::betweenness_centrality_clustering &mdash; Graph
+clustering based on edge betweenness centrality.</p>
+</div>
+<h2 xmlns:rev=
+"http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class=
+"refsynopsisdiv-title">Synopsis</h2>
+<div xmlns:rev=
+"http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class=
+"refsynopsisdiv">
+<pre class="synopsis">
+<span class="bold"><b>template</b></span>&lt;<span class=
+"bold"><b>typename</b></span> MutableGraph, <span class=
+"bold"><b>typename</b></span> Done, <span class=
+"bold"><b>typename</b></span> EdgeCentralityMap, 
+         <span class=
+"bold"><b>typename</b></span> VertexIndexMap&gt; 
+  <span class="type"><span class=
+"bold"><b>void</b></span></span> betweenness_centrality_clustering(MutableGraph &amp; g, Done done, 
+                                         EdgeCentralityMap edge_centrality, 
+                                         VertexIndexMap vertex_index);
+<span class="bold"><b>template</b></span>&lt;<span class=
+"bold"><b>typename</b></span> MutableGraph, <span class=
+"bold"><b>typename</b></span> Done, <span class=
+"bold"><b>typename</b></span> EdgeCentralityMap&gt; 
+  <span class="type"><span class=
+"bold"><b>void</b></span></span> betweenness_centrality_clustering(MutableGraph &amp; g, Done done, 
+                                         EdgeCentralityMap edge_centrality);
+<span class="bold"><b>template</b></span>&lt;<span class=
+"bold"><b>typename</b></span> MutableGraph, <span class=
+"bold"><b>typename</b></span> Done&gt; 
+  <span class="type"><span class=
+"bold"><b>void</b></span></span> betweenness_centrality_clustering(MutableGraph &amp; g, Done done);
+</pre></div>
+<div class="refsect1" lang="en"><a name="id822306" id=
+"id822306"></a>
+<h2>Description</h2>
+<p>This algorithm implements graph clustering based on edge
+betweenness centrality. It is an iterative algorithm, where in each
+step it computes the edge betweenness centrality (via <a href=
+"betweenness_centrality.html">brandes_betweenness_centrality</a>) and
+removes the edge with the maximum betweenness centrality. The
+<tt class="computeroutput">done</tt> function object determines
+when the algorithm terminates (the edge found when the algorithm
+terminates will not be removed).</p>
+
+<h2>Parameters</h2>
+IN: <tt>const Graph&amp; g</tt>
+<blockquote>
+  The graph object on which the algorithm will be applied.  The type
+  <tt>Graph</tt> must be a model of <a
+  href="VertexListGraph.html">Vertex List Graph</a> and <a
+  href="IncidenceGraph.html">Incidence Graph</a>. When an edge
+  centrality map is supplied, it must also model <a
+  href="EdgeListGraph.html">Edge List Graph</a> and <a
+  href="MutableGraph.html">MutableGraph</a>.<br>
+
+<b>Python</b>: The parameter is named <tt>graph</tt>.
+</blockquote>
+
+IN: <tt>Done done</tt>
+<blockquote>
+The function object that indicates termination of the algorithm.
+It must be a ternary function object thats accepts the maximum
+centrality, the descriptor of the edge that will be removed, and
+the graph <tt class="computeroutput">g</tt>.<br>
+<b>Python</b>: Any callable Python object will suffice.
+</blockquote>
+
+OUT/UTIL: <tt>EdgeCentralityMap edge_centrality_map</tt>
+<blockquote>
+  This property map is used to accumulate the betweenness centrality
+  of each edge, and is a secondary form of output for the
+  algorithm. The type <tt>EdgeCentralityMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a>, with the graph's edge descriptor type as its key
+  type. The value type of this property map should be the same as the
+  value type of the <tt>CentralityMap</tt> property map.<br>
+
+  <b>Default:</b> a <tt>dummy_property_map</tt>, which requires no
+  work to compute and returns no answer.<br>
+  <b>Python</b>: The color map must be a <tt>edge_double_map</tt> for
+  the graph.<br>
+  <b>Python default</b>: <tt>graph.get_edge_double_map("centrality")</tt>
+</blockquote>
+
+IN: <tt>VertexIndexMap vertex_index</tt> 
+<blockquote>
+  This maps each vertex to an integer in the range <tt>[0,
+    num_vertices(g))</tt>. This is necessary for efficient updates of the
+  heap data structure when an edge is relaxed.  The type
+  <tt>VertexIndexMap</tt> must be a model of
+  <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a>. The value type of the map must be an
+  integer type. The vertex descriptor type of the graph needs to be
+  usable as the key type of the map.<br>
+  <b>Default:</b> <tt>get(vertex_index, g)</tt>.
+    Note: if you use this default, make sure your graph has
+    an internal <tt>vertex_index</tt> property. For example,
+    <tt>adjacency_list</tt> with <tt>VertexList=listS</tt> does
+    not have an internal <tt>vertex_index</tt> property.<br>
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+<table xmlns:rev=
+"http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width=
+"100%">
+<tr>
+<td align="left"></td>
+<td align="right"></td>
+</tr>
+</table>
+<h3>Where Defined</h3>
+&lt;<a href=
+"../../../boost/graph/bc_clustering.hpp">boost/graph/bc_clustering.hpp</a>&gt;
+<hr>
+<table>
+<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)<br>
+<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>
+</body>
+</html>

doc/bellman_ford_shortest.html

@@ -0,0 +1,349 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Bellman Ford Shortest Paths</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+
+<H1><A NAME="sec:bellman-ford"></A><img src="figs/python.gif" alt="(Python)"/>
+<TT>bellman_ford_shortest_paths</TT>
+</H1>
+
+<P>
+<PRE>
+<i>// named paramter version</i>
+template &lt;class <a href="./EdgeListGraph.html">EdgeListGraph</a>, class Size, class P, class T, class R&gt;
+bool bellman_ford_shortest_paths(const EdgeListGraph&amp; g, Size N, 
+  const bgl_named_params&lt;P, T, R&gt;&amp; params = <i>all defaults</i>);
+
+template &lt;class <a href="./VertexAndEdgeListGraph.html">VertexAndEdgeListGraph</a>, class P, class T, class R&gt;
+bool bellman_ford_shortest_paths(const VertexAndEdgeListGraph&amp; g,
+  const bgl_named_params&lt;P, T, R&gt;&amp; params = <i>all defaults</i>);
+
+<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.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, 
+  BinaryFunction combine, BinaryPredicate compare, BellmanFordVisitor v)
+</PRE>
+
+<P>
+The Bellman-Ford algorithm&nbsp;[<A
+HREF="bibliography.html#bellman58">4</A>,<A
+HREF="bibliography.html#ford62:_flows">11</A>,<A
+HREF="bibliography.html#lawler76:_comb_opt">20</A>,<A
+HREF="bibliography.html#clr90">8</A>] solves the single-source
+shortest paths problem for a graph with both positive and negative
+edge weights. For the definition of the shortest paths problem see
+Section <A
+HREF="./graph_theory_review.html#sec:shortest-paths-algorithms">Shortest-Paths
+Algorithms</A>. 
+If you only need to solve the shortest paths problem for positive edge
+weights, Dijkstra's algorithm provides a more efficient
+alternative. If all the edge weights are all equal to one then breadth-first
+search provides an even more efficient alternative.
+</p>
+
+<p>
+Before calling the <tt>bellman_ford_shortest_paths()</tt> function,
+the user must assign the source vertex a distance of zero and all
+other vertices a distance of infinity <i>unless</i> you are providing
+a starting vertex. The Bellman-Ford algorithm
+proceeds by looping through all of the edges in the graph, applying
+the relaxation operation to each edge. In the following pseudo-code,
+<i>v</i> is a vertex adjacent to <i>u</i>, <i>w</i> maps edges to
+their weight, and <i>d</i> is a distance map that records the length
+of the shortest path to each vertex seen so far. <i>p</i> is a
+predecessor map which records the parent of each vertex, which will
+ultimately be the parent in the shortest paths tree
+</p>
+
+<table>
+<tr>
+<td valign="top">
+<pre>
+RELAX(<i>u</i>, <i>v</i>, <i>w</i>, <i>d</i>, <i>p</i>)
+  <b>if</b> (<i>w(u,v) + d[u] < d[v]</i>) 
+    <i>d[v] := w(u,v) + d[u]</i>
+    <i>p[v] := u</i>
+  <b>else</b>
+    ...
+</pre>
+</td>
+<td valign="top">
+<pre>
+
+
+relax edge <i>(u,v)</i>
+
+
+edge <i>(u,v)</i> is not relaxed 
+</pre>
+</td>
+</tr>
+</table>
+
+<p>
+The algorithm repeats this loop <i>|V|</i> times after which it is
+guaranteed that the distances to each vertex have been reduced to the
+minimum possible unless there is a negative cycle in the graph. If
+there is a negative cycle, then there will be edges in the graph that
+were not properly minimized. That is, there will be edges <i>(u,v)</i> such
+that <i>w(u,v) + d[u] < d[v]</i>.  The algorithm loops over the edges in
+the graph one final time to check if all the edges were minimized,
+returning <tt>true</tt> if they were and returning <tt>false</tt>
+otherwise.
+</p>
+
+<table>
+<tr>
+<td valign="top">
+<pre>
+BELLMAN-FORD(<i>G</i>)
+  <i>// Optional initialization</i>
+  <b>for</b> each vertex <i>u in V</i> 
+    <i>d[u] := infinity</i>
+    <i>p[u] := u</i> 
+  <b>end for</b>
+  <b>for</b> <i>i := 1</i> <b>to</b> <i>|V|-1</i> 
+    <b>for</b> each edge <i>(u,v) in E</i> 
+      RELAX(<i>u</i>, <i>v</i>, <i>w</i>, <i>d</i>, <i>p</i>)
+    <b>end for</b>
+  <b>end for</b>
+  <b>for</b> each edge <i>(u,v) in E</i> 
+    <b>if</b> (<i>w(u,v) + d[u] < d[v]</i>)
+      <b>return</b> (false, , )
+    <b>else</b> 
+      ...
+  <b>end for</b>
+  <b>return</b> (true, <i>p</i>, <i>d</i>)
+</pre>
+</td>
+<td valign="top">
+<pre>
+
+
+
+
+
+
+
+examine edge <i>(u,v)</i>
+
+
+
+
+
+edge <i>(u,v)</i> was not minimized 
+
+edge <i>(u,v)</i> was minimized 
+</pre>
+</td>
+</tr>
+</table>
+
+There are two main options for obtaining output from the
+<tt>bellman_ford_shortest_paths()</tt> function. If the user provides
+a distance property map through the <tt>distance_map()</tt> parameter
+then the shortest distance from the source vertex to every other
+vertex in the graph will be recorded in the distance map (provided the
+function returns <tt>true</tt>). The second option is recording the
+shortest paths tree in the <tt>predecessor_map()</tt>. For each vertex
+<i>u in V</i>, <i>p[u]</i> will be the predecessor of <i>u</i> in the
+shortest paths tree (unless <i>p[u] = u</i>, in which case <i>u</i> is
+either the source vertex or a vertex unreachable from the source).  In
+addition to these two options, the user can provide her own
+custom-made visitor that can take actions at any of the
+algorithm's event points.
+
+<P>
+
+<h3>Parameters</h3>
+
+
+IN: <tt>EdgeListGraph&amp; g</tt> 
+<blockquote>
+  A directed or undirected graph whose type must be a model of
+  <a href="./EdgeListGraph.html">Edge List Graph</a>. If a root vertex is
+  provided, then the graph must also model
+  <a href="./VertexListGraph.html">Vertex List Graph</a>.<br>
+
+  <b>Python</b>: The parameter is named <tt>graph</tt>.
+</blockquote>
+
+IN: <tt>Size N</tt>
+<blockquote>
+  The number of vertices in the graph. The type <tt>Size</tt> must
+  be an integer type.<br>
+  <b>Default:</b> <tt>num_vertices(g)</tt>.<br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+
+<h3>Named Parameters</h3>
+
+IN: <tt>weight_map(WeightMap w)</tt>
+<blockquote>
+  The weight (also know as ``length'' or ``cost'') 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>.  The key type for this property map must be the edge
+  descriptor of the graph.  The value type for the weight map must be
+  <i>Addable</i> with the distance map's value type. <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>
+  <b>Python default</b>: <tt>graph.get_edge_double_map("weight")</tt>
+</blockquote>
+
+OUT: <tt>predecessor_map(PredecessorMap p_map)</tt> 
+<blockquote>
+  The predecessor map records the edges in the minimum spanning
+  tree. Upon completion of the algorithm, the edges <i>(p[u],u)</i>
+  for all <i>u in V</i> are in the minimum spanning tree. If <i>p[u] =
+  u</i> then <i>u</i> is either the source vertex or a vertex that is
+  not reachable from the source.  The <tt>PredecessorMap</tt> type
+  must be a <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a> which key and vertex types the same as the vertex
+  descriptor type of the graph.<br>
+  <b>Default:</b> <tt>dummy_property_map</tt><br>
+
+  <b>Python</b>: Must be a <tt>vertex_vertex_map</tt> for the graph.<br>
+</blockquote>
+
+IN/OUT: <tt>distance_map(DistanceMap d)</tt> 
+<blockquote>
+  The shortest path weight from the source vertex to each vertex in
+  the graph <tt>g</tt> is recorded in this property map.  The type
+  <tt>DistanceMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  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.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>
+</blockquote>
+
+IN: <tt>root_vertex(Vertex s)</tt>
+<blockquote>
+  The starting (or "root") vertex from which shortest paths will be
+  computed. When provided, the distance map need not be initialized
+  (the algorithm will perform the initialization itself). However, the
+  graph must model <a href="./VertexListGraph.html">Vertex List
+  Graph</a> when this parameter is provided.<br>
+  <b>Default:</b> None; if omitted, the user must initialize the
+  distance map.
+</blockquote>
+
+IN: <tt>visitor(BellmanFordVisitor v)</tt>
+<blockquote>
+  The visitor object, whose type must be a model of
+  <a href="./BellmanFordVisitor.html">Bellman-Ford Visitor</a>.
+  The visitor object is passed by value <a
+  href="#1">[1]</a>.
+<br>
+  <b>Default:</b> <tt>bellman_visitor&lt;null_visitor&gt;</tt><br>
+
+  <b>Python</b>: The parameter should be an object that derives from
+  the <a
+  href="BellmanFordVisitor.html#python"><tt>BellmanFordVisitor</tt></a> type
+  of the graph.
+
+</blockquote>
+
+IN: <tt>distance_combine(BinaryFunction combine)</tt>
+<blockquote>
+  This function object replaces the role of addition in the relaxation
+  step. The first argument type must match the distance map's value
+  type and the second argument type must match the weight map's value
+  type.  The result type must be the same as the distance map's value
+  type.<br>
+  <b>Default:</b><tt>std::plus&lt;D&gt;</tt>
+  with <tt>D=typename&nbsp;property_traits&lt;DistanceMap&gt;::value_type</tt>.<br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+IN: <tt>distance_compare(BinaryPredicate compare)</tt>
+<blockquote>
+  This function object replaces the role of the less-than operator
+  that compares distances in the relaxation step. The argument types
+  must match the distance map's value type.<br>
+  <b>Default:</b> <tt>std::less&lt;D&gt;</tt>
+  with <tt>D=typename&nbsp;property_traits&lt;DistanceMap&gt;::value_type</tt>.<br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+<P>
+
+<H3>Complexity</H3>
+
+<P>
+The time complexity is <i>O(V E)</i>.
+
+
+<h3>Visitor Event Points</h3>
+
+<ul>
+<li><b><tt>vis.examine_edge(e, g)</tt></b>  is invoked on every edge in
+  the graph <i>|V|</i> times.
+<li><b><tt>vis.edge_relaxed(e, g)</tt></b>  is invoked when the distance
+  label for the target vertex is decreased. The edge <i>(u,v)</i> that 
+  participated in the last relaxation for vertex <i>v</i> is an edge in the
+  shortest paths tree. 
+<li><b><tt>vis.edge_not_relaxed(e, g)</tt></b>  is invoked if the distance label
+  for the target vertex is not decreased. 
+<li><b><tt>vis.edge_minimized(e, g)</tt></b>  is invoked during the
+  second stage of the algorithm, during the test of whether each edge
+  was minimized. If the edge is minimized then this function
+  is invoked.
+<li><b><tt>vis.edge_not_minimized(e, g)</tt></b>  is also invoked during the
+  second stage of the algorithm, during the test of whether each edge
+  was minimized.  If the edge was not minimized, this function is
+  invoked.  This happens when there is a negative cycle in the graph.
+</ul>
+
+<H3>Example</H3>
+
+<P>
+An example of using the Bellman-Ford algorithm is in <a
+href="../example/bellman-example.cpp"><TT>examples/bellman-example.cpp</TT></a>.
+
+<h3>Notes</h3>
+
+<p><a name="1">[1]</a> 
+  Since the visitor parameter is passed by value, if your visitor
+  contains state then any changes to the state during the algorithm
+  will be made to a copy of the visitor object, not the visitor object
+  passed in. Therefore you may want the visitor to hold this state by
+  pointer or reference.
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 

doc/bellman_visitor.html

@@ -1,20 +1,16 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  We make no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>Boost Graph Library: bellman_visitor</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -26,7 +22,7 @@ bellman_visitor&lt;EventVisitorList&gt;
 </H1>
 
 This class is an adapter that converts a list of <a
-href="./EventVisitor.html">EventVisitor</a>'s (constructed using
+href="./EventVisitor.html">EventVisitor</a>s (constructed using
 <tt>std::pair</tt>) into a <a
 href="./BellmanFordVisitor.html">BellmanFordVisitor</a>.
 
@@ -67,7 +63,7 @@ with <tt>std::pair</tt>.
 This class implements all of the member functions required by <a
 href="./BellmanFordVisitor.html">BellmanFordVisitor</a>. In each function the
 appropriate event is dispatched to the <a
-href="./EventVisitor.html">EventVisitor</a>'s in the EventVisitorList.
+href="./EventVisitor.html">EventVisitor</a> in the EventVisitorList.
 
 <h3>Non-Member Functions</h3>
 
@@ -101,14 +97,14 @@ and <a href="./property_writer.html"><tt>property_writer</tt></a>.
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~llee1>Lie-Quan Lee</A>, Univ.of Notre Dame (<A HREF="mailto:llee1@lsc.nd.edu">llee1@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~lums>Andrew Lumsdaine</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:lums@lsc.nd.edu">lums@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
 
 </BODY>

doc/betweenness_centrality.html

@@ -0,0 +1,307 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<!--
+     Copyright (c) 2004 Trustees of Indiana University
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+  <head>
+    <title>Boost Graph Library: Brandes' Betweenness Centrality</title>
+  </head>
+
+  <body>
+    <IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+<h1><img src="figs/python.gif" alt="(Python)"/><tt>brandes_betweenness_centrality</tt></h1>
+
+    <p>
+    <pre>
+<em>// named parameter versions</em>
+template&lt;typename Graph, typename Param, typename Tag, typename Rest&gt;
+void 
+brandes_betweenness_centrality(const Graph&amp; g,
+                               const bgl_named_params&lt;Param,Tag,Rest&gt;&amp; params);
+
+template&lt;typename Graph, typename CentralityMap&gt;
+void 
+brandes_betweenness_centrality(const Graph&amp; g, CentralityMap centrality_map);
+
+template&lt;typename Graph, typename CentralityMap, typename EdgeCentralityMap&gt;
+void 
+brandes_betweenness_centrality(const Graph&amp; g, CentralityMap centrality_map,
+                               EdgeCentralityMap edge_centrality);
+
+<em>// non-named parameter versions</em>
+template&lt;typename Graph, typename CentralityMap, typename EdgeCentralityMap,
+         typename IncomingMap, typename DistanceMap, typename DependencyMap, 
+         typename PathCountMap, typename VertexIndexMap&gt;
+void 
+brandes_betweenness_centrality(const Graph&amp; g, CentralityMap centrality_map,
+                               EdgeCentralityMap edge_centrality,
+                               IncomingMap incoming,
+                               DistanceMap distance, DependencyMap dependency,
+                               PathCountMap path_count, 
+                               VertexIndexMap vertex_index);
+
+template&lt;typename Graph, typename CentralityMap, typename EdgeCentralityMap,
+         typename IncomingMap, typename DistanceMap, typename DependencyMap, 
+         typename PathCountMap, typename VertexIndexMap, typename WeightMap&gt;    
+void 
+brandes_betweenness_centrality(const Graph&amp; g, CentralityMap centrality_map,
+                               EdgeCentralityMap edge_centrality,
+                               IncomingMap incoming, 
+                               DistanceMap distance,  DependencyMap dependency,
+                               PathCountMap path_count,      
+                               VertexIndexMap vertex_index,
+                               WeightMap weight_map);
+
+<em>// helper functions</em>
+template&lt;typename Graph, typename CentralityMap&gt;
+void 
+relative_betweenness_centrality(const Graph&amp; g, CentralityMap centrality_map);
+
+template&lt;typename Graph, typename CentralityMap&gt;
+typename property_traits&lt;CentralityMap&gt;::value_type
+central_point_dominance(const Graph&amp; g, CentralityMap centrality_map);
+    </pre>
+
+<p>This algorithm&nbsp;[<a href="bibliography.html#brandes01">54</a>]
+computes the <em>betweenness centrality</em>&nbsp;[<a
+href="bibliography.html#freeman77">55</a>,<a
+href="bibliography.html#anthonisse71">56</a>] of each vertex or each
+edge in the graph. The betweenness centrality of a vertex <em>v</em>
+is defined by
+
+<p><img src="figs/betweenness_centrality.gif">,
+
+<p>where <img src="figs/sigma_st.gif"> is the number of shortest paths from
+vertex <em>s</em> to vertex <em>t</em> and <img src="figs/sigma_stv.gif">
+is the number of shortest paths from vertex <em>s</em> to vertex
+<em>t</em> that pass through vertex <em>v</em>.
+
+<!-- \sum_{s \neq v \neq t}\frac{\sigma_{st}(v)}{\sigma_{st}} -->
+
+<p>The edge betweenness centrality indicates for each edge the
+betweenness centrality that was contributed to the target(s) of the
+edge (plural for undirected graphs). Similar to (vertex) betweenness
+centrality, edge betweenness centrality can be used to determine the
+edges through which most shortest paths must pass. A single invocation
+of this algorithm can compute either the vertex or edge centrality (or
+both).</p>
+
+<p>This algorithm can operate either on weighted graphs (if a suitable
+edge weight map is supplied) or unweighted graphs (if no edge weight
+map is supplied). The result is the absolute betweenness centrality;
+to convert to the relative betweenness centrality, which scales each
+absolute centrality by <img src="figs/rel_betweenness_centrality.gif">
+(where <em>n</em> is the number of vertices in the graph), use
+<tt>relative_betweenness_centrality</tt>. Given the relative
+betweenness centrality, one can compute the <em>central point
+dominance</em>&nbsp;[<a href="bibliography.html#freeman77">55</a>], which is a measure of the maximum "betweenness" of any
+point in the graph: it will be 0 for complete graphs and
+1 for "wheel" graphs (in which there is a central vertex that all
+paths include; see <a href="#Fig1">Fig. 1</a>). Let <img src="figs/v_star.gif"> be the vertex with the largest relative betweenness centrality; then, the central point dominance is defined as:
+
+<p><img src="figs/central_point_dominance.gif">
+
+<!-- C_B' = \frac{\sum_{v \in V} C_B(v^*) - C_B'(v)}{n-1} -->
+
+<p><a name="Fig1">
+    <table border="1">
+      <thead>
+        <tr>
+          <th>Fig. 1: A wheel graph, where every path travels through the central node. <br>The central point dominance of this graph is 1.</td>
+        </tr>
+      </thead>
+      <tbody>
+        <tr>
+          <td align="center"><img src="figs/wheel_graph.gif"></td>
+        </tr>
+      </tbody>
+    </table>
+
+<h3>Where Defined</h3>
+<a href="../../../boost/graph/betweenness_centrality.hpp"><tt>boost/graph/betweenness_centrality.hpp</tt></a>
+
+<h3>Parameters</h3>
+IN: <tt>const Graph&amp; g</tt>
+<blockquote>
+  The graph object on which the algorithm will be applied.  The type
+  <tt>Graph</tt> must be a model of <a
+  href="VertexListGraph.html">Vertex List Graph</a> and <a
+  href="IncidenceGraph.html">Incidence Graph</a>. When an edge
+  centrality map is supplied, it must also model <a
+  href="EdgeListGraph.html">Edge List Graph</a>.<br>
+
+<b>Python</b>: The parameter is named <tt>graph</tt>.
+</blockquote>
+    
+UTIL: <tt>IncomingMap incoming</tt> 
+<blockquote>
+  This property map records the set of edges incoming to each vertex that comprise a shortest path from a particular source vertex through this vertex, and is used internally by the algorithm.The <tt>IncomingMap</tt> type must be a <a
+  href="../../property_map/doc/LvaluePropertyMap.html">Lvalue Property
+  Map</a> whose key type is the same as the vertex descriptor type of
+  the graph and whose value type is a Sequence (e.g., an
+  <tt>std::vector</tt>) containing edge descriptors.<br>
+
+  <b>Default:</b> <a
+  href="../../property_map/doc/iterator_property_map.html">
+  <tt>iterator_property_map</tt></a> created from a
+  <tt>std::vector</tt> of <tt>std::vector&lt;Edge&gt;</tt>, where
+  <tt>Edge</tt> is the edge descriptor type of the graph.<br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+UTIL: <tt>DistanceMap distance_map</tt> 
+<blockquote>
+  The shortest path weight from each source vertex <tt>s</tt> to each
+  vertex in the graph <tt>g</tt> is recorded in this property map, but
+  the result is only used internally. The type <tt>DistanceMap</tt>
+  must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a>. The vertex descriptor type of the graph needs to
+  be usable as the key type of the distance map. The value type of the
+  distance map is the element type of a <a
+  href="./Monoid.html">Monoid</a>.<br>
+
+  <b>Default:</b> <a
+  href="../../property_map/doc/iterator_property_map.html">
+  <tt>iterator_property_map</tt></a> created from a
+  <tt>std::vector</tt> of the <tt>WeightMap</tt>'s value type (or the
+  <tt>vertices_size_type</tt> of the graph when no weight map exists)
+  of size <tt>num_vertices(g)</tt> and using the <tt>vertex_index</tt> for
+  the index map.<br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+UTIL: <tt>DependencyMap dependency</tt> 
+<blockquote>
+  Property map used internally to accumulate partial betweenness
+  centrality results. The type <tt>DependencyMap</tt> must be a model
+  of <a href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a>. The vertex descriptor type of the graph needs to
+  be usable as the key type of the dependency map. The value type of
+  the dependency map must be compatible with the value type of the
+  centrality map.<br>
+
+  <b>Default:</b> <a
+  href="../../property_map/doc/iterator_property_map.html">
+  <tt>iterator_property_map</tt></a> created from a
+  <tt>std::vector</tt> of the <tt>CentralityMap</tt>'s value type of
+  size <tt>num_vertices(g)</tt> and using the <tt>vertex_index</tt>
+  for the index map.<br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+UTIL: <tt>PathCountMap path_count</tt> 
+<blockquote>
+  Property map used internally to accumulate the number of paths that
+  pass through each particular vertex. The type <tt>PathCountMap</tt>
+  must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a>. The vertex descriptor type of the graph needs to
+  be usable as the key type of the dependency map. The value type of
+  the dependency map must be an integral type large enough to store
+  the number of paths in the graph.<br>
+
+  <b>Default:</b> <a
+  href="../../property_map/doc/iterator_property_map.html">
+  <tt>iterator_property_map</tt></a> created from a
+  <tt>std::vector</tt> of the <tt>degree_size_type</tt> of the graph of
+  size <tt>num_vertices(g)</tt> and using the <tt>vertex_index</tt>
+  for the index map.<br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+<h3>Named parameters</h3>
+OUT/UTIL: <tt>CentralityMap centrality_map</tt>
+<blockquote>
+  This property map is used to accumulate the betweenness centrality
+  of each vertex, and is the primary output of the algorithm. The type
+  <tt>CentralityMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a>, with the graph's vertex descriptor type as its key
+  type. The value type of this property map should be a floating-point
+  or rational type.<br>
+
+  <b>Default:</b> a <tt>dummy_property_map</tt>, which requires no
+  work to compute and returns no answer.<br>
+  <b>Python</b>: The color map must be a <tt>vertex_double_map</tt> for
+  the graph.<br>
+  <b>Python default</b>: <tt>graph.get_vertex_double_map("centrality")</tt>
+</blockquote>
+
+OUT/UTIL: <tt>EdgeCentralityMap edge_centrality_map</tt>
+<blockquote>
+  This property map is used to accumulate the betweenness centrality
+  of each edge, and is a secondary form of output for the
+  algorithm. The type <tt>EdgeCentralityMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a>, with the graph's edge descriptor type as its key
+  type. The value type of this property map should be the same as the
+  value type of the <tt>CentralityMap</tt> property map.<br>
+
+  <b>Default:</b> a <tt>dummy_property_map</tt>, which requires no
+  work to compute and returns no answer.<br>
+  <b>Python</b>: The color map must be a <tt>edge_double_map</tt> for
+  the graph.<br>
+  <b>Python default</b>: <tt>graph.get_edge_double_map("centrality")</tt>
+</blockquote>
+
+IN: <tt>vertex_index_map(VertexIndexMap vertex_index)</tt> 
+<blockquote>
+  This maps each vertex to an integer in the range <tt>[0,
+    num_vertices(g))</tt>. This is necessary for efficient updates of the
+  heap data structure when an edge is relaxed.  The type
+  <tt>VertexIndexMap</tt> must be a model of
+  <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a>. The value type of the map must be an
+  integer type. The vertex descriptor type of the graph needs to be
+  usable as the key type of the map.<br>
+  <b>Default:</b> <tt>get(vertex_index, g)</tt>.
+    Note: if you use this default, make sure your graph has
+    an internal <tt>vertex_index</tt> property. For example,
+    <tt>adjacency_list</tt> with <tt>VertexList=listS</tt> does
+    not have an internal <tt>vertex_index</tt> property.<br>
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+IN: <tt>weight_map(WeightMap w_map)</tt>   
+<blockquote>
+  The weight or ``length'' of each edge in the graph. The weights
+  must all be non-negative, and the algorithm will throw a
+  <a href="./exception.html#negative_edge"><tt>negative_edge</tt></a> 
+  exception is one of the edges is negative.
+  The type <tt>WeightMap</tt> must be a model of
+  <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a>. The edge descriptor type of
+  the graph needs to be usable as the key type for the weight
+  map. The value type for this map must be
+  the same as the value type of the distance map.<br>
+  <b>Default:</b> All edge weights are assumed to be equivalent.
+  <b>Python</b>: If supplied, must be an <tt>edge_double_map</tt> for the graph.
+</blockquote>
+
+<h3>Complexity</h3> 
+The time complexity is <em>O(VE)</em> for unweighted graphs and
+<em>O(VE + V(V+E) log V)</em> for weighted graphs. The space complexity
+is <em>O(VE)</em>.
+
+    <hr>
+
+<TABLE>
+<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="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>
+<!-- Created: Fri Jun  4 16:42:50 EST 2004 -->
+<!-- hhmts start -->Last modified: Tue Mar  1 14:14:51 EST 2005 <!-- hhmts end -->
+  </body>
+</html>

doc/bfs_visitor.html

@@ -1,20 +1,16 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  We make no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>Boost Graph Library: bfs_visitor</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -26,14 +22,14 @@ bfs_visitor&lt;EventVisitorList&gt;
 </H1>
 
 This class is an adapter that converts a list of <a
-href="./EventVisitor.html">EventVisitor</a>'s (constructed using
+href="./EventVisitor.html">EventVisitor</a>s (constructed using
 <tt>std::pair</tt>) into a <a href="./BFSVisitor.html">BFSVisitor</a>.
 
 
 <h3>Example</h3>
 
 This is an excerpt from <a
-href="../examples/bfs.cpp"><tt>examples/bfs.cpp</tt></a> where three
+href="../example/bfs.cpp"><tt>examples/bfs.cpp</tt></a> where three
 event-visitors are combined to make a BFS visitor. The functions
 <tt>boost::record_distances</tt>, <tt>boost::record_predecessors</tt>,
 and <tt>copy_graph</tt> are all functions that create an event
@@ -43,7 +39,7 @@ visitor.
   // Construct graph G and obtain the source vertex s ...
 
   boost::breadth_first_search(G, s, 
-   make_bfs_visitor(
+   boost::make_bfs_visitor(
     std::make_pair(boost::record_distances(d, boost::on_tree_edge()),
     std::make_pair(boost::record_predecessors(p.begin(), 
                                               boost::on_tree_edge()),
@@ -84,7 +80,7 @@ with <tt>std::pair</tt>.
 This class implements all of the member functions required by <a
 href="./BFSVisitor.html">BFSVisitor</a>. In each function the
 appropriate event is dispatched to the <a
-href="./EventVisitor.html">EventVisitor</a>'s in the EventVisitorList.
+href="./EventVisitor.html">EventVisitor</a> in the EventVisitorList.
 
 <h3>Non-Member Functions</h3>
 
@@ -118,14 +114,14 @@ and <a href="./property_writer.html"><tt>property_writer</tt></a>.
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~llee1>Lie-Quan Lee</A>, Univ.of Notre Dame (<A HREF="mailto:llee1@lsc.nd.edu">llee1@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~lums>Andrew Lumsdaine</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:lums@lsc.nd.edu">lums@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
 
 </BODY>

doc/bgl_named_params.html

@@ -0,0 +1,96 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Named Parameters</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><A NAME="sec:bgl-named-params"></A>
+<pre>
+bgl_named_params&lt;Param, Type, Rest&gt;
+</pre>
+</H1>
+
+<p>
+Many of the Boost.Graph algorithms have a long list of parameters,
+most of which have default values. This causes several problems.
+First, C++ does not provide a mechanism for handling default
+parameters of template functions. However, this can be overcome by
+creating multiply version of an algorithm with different numbers of
+parameters with each version providing defaults for some subset of
+the parameters. This is the approach used in previous versions of
+Boost.Graph. This solution is still unsatisfactory for several
+reasons:
+
+<ul>
+  <li>The defaults for parameters can only been used in a particular
+  order. If the ordering of the defaults does not fit the users situation
+  he or she has to resort to providing all the parameters.
+
+  <li>Since the list of parameters is long, it is easy to forget
+   the ordering. 
+</ul>
+
+<p>
+A better solution is provided by <tt>bgl_named_params</tt>. This class
+allows users to provide parameters is any order, and matches
+arguments to parameters based on parameter names.
+
+<p>
+The following code shows an example of calling
+<tt>bellman_ford_shortest_paths</tt> using the named parameter
+technique. Each of the arguments is passed to a function whose name
+indicates which parameter the argument is for. Each of the named
+parameters is separated by a <b>period</b>, not a comma.
+
+<pre>
+  bool r = boost::bellman_ford_shortest_paths(g, int(N), 
+     boost::weight_map(weight).
+     distance_map(&amp;distance[0]).
+     predecessor_map(&amp;parent[0]));
+</pre>
+
+<p>The order in which the arguments are provided does not matter as
+long as they are matched with the correct parameter function.  Here is
+an call to <tt>bellman_ford_shortest_paths</tt> that is equivalent to
+the one above.
+
+<pre>
+  bool r = boost::bellman_ford_shortest_paths(g, int(N), 
+     boost::predecessor_map(&amp;parent[0]).
+     distance_map(&amp;distance[0]).
+     weight_map(weight));
+</pre>
+
+<p>Typically the user never needs to deal with the
+<tt>bgl_named_params</tt> class directly, since there are functions
+like <tt>boost::weight_map</tt> that create an instance of
+<tt>bgl_named_params</tt>.
+
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
+
+</BODY>
+</HTML>

doc/bibliography.html

@@ -0,0 +1,467 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Bibliography</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+
+<H2>Bibliography</H2>
+
+<DL COMMapCT><DD><P></P><DT><A NAME="aho83:_data_struct_algo">1</A>
+<DD>
+A.&nbsp;V. Aho, J.&nbsp;E. Hopcroft, and J.&nbsp;D. Ullman.
+<BR><EM>Data Structures and Algorithms</EM>.
+<BR>Addison-Wesley, 1983.
+
+<P></P><DT><A NAME="austern99:_gener_progr_stl">2</A>
+<DD>
+M.&nbsp;H. Austern.
+<BR><EM>Generic Programming and the STL</EM>.
+<BR>Professional computing series. Addison-Wesley, 1999.
+
+<P></P><DT><A NAME="baumgartner95:_signatures">3</A>
+<DD>
+G.&nbsp;Baumgartner and V.&nbsp;F. Russo.
+<BR>Signatures: A language extension for improving type abstraction and
+  subtype polymorphism in C++.
+<BR><EM>Software-Practice and Experience</EM>, 25(8):863-889, August 1995.
+
+<P></P><DT><A NAME="bellman58">4</A>
+<DD>
+R.&nbsp;Bellman.
+<BR>On a routing problem.
+<BR><EM>Quarterly of Applied Mathematics</EM>, 16(1):87-90, 1958.
+
+<P></P><DT><A NAME="bruce95">5</A>
+<DD>
+K.&nbsp;B. Bruce, L.&nbsp;Cardelli, G.&nbsp;Castagna, the Hopkins Objects&nbsp;Group, G.&nbsp;T.
+  Leavens, and B.&nbsp;Pierce.
+<BR>On binary methods.
+<BR><EM>Theory and Practice of Object Systems</EM>, 1:221-242, 1995.
+
+<P></P><DT><A NAME="coleman85:_algor">6</A>
+<DD>
+T.&nbsp;F. Coleman, B.&nbsp;S. Garbow, and J.&nbsp;J. Mor'e.
+<BR>Algorithm 649: Fortran subroutines for estimating sparse hessian
+  matrices.
+<BR><EM>ACM Transactions on Mathematical Software</EM>, 11(4):378, December
+  1985.
+
+<P></P><DT><A NAME="coleman84:_estim_jacob">7</A>
+<DD>
+T.&nbsp;F. Coleman and J.&nbsp;J. Mor'e.
+<BR>Estimation of sparse jacobian matrices and graph coloring problems.
+<BR><EM>SIAM Journal on Numerical Analysis</EM>, 20:187-209,, 1984.
+
+<P></P><DT><A NAME="clr90">8</A>
+<DD>
+T.&nbsp;Cormen, C.&nbsp;Leiserson, and R.&nbsp;Rivest.
+<BR><EM>Introduction to Algorithms</EM>.
+<BR>McGraw-Hill, 1990.
+
+<P></P><DT><A NAME="curtis74:_jacob">9</A>
+<DD>
+A.&nbsp;Curtis, M.&nbsp;Powell, and J.&nbsp;Reid.
+<BR>On the estimation of sparse jacobian matrices.
+<BR><EM>Journal of the Institute of Mathematics and its Applications</EM>,
+  13:117-119, 1974.
+
+<P></P><DT><A NAME="dijkstra59">10</A>
+<DD>
+E.&nbsp;Dijkstra.
+<BR>A note on two problems in connexion with graphs.
+<BR><EM>Numerische Mathematik</EM>, 1:269-271, 1959.
+
+<P></P><DT><A NAME="ford62:_flows">11</A>
+<DD>
+L.&nbsp;R. Ford and D.&nbsp;R. Fulkerson.
+<BR><EM>Flows in networks</EM>.
+<BR>Princeton University Press, 1962.
+
+<P></P><DT><A NAME="gamma95:_design_patterns">12</A>
+<DD>
+E.&nbsp;Gamma, R.&nbsp;Helm, R.&nbsp;Johnson, and J.&nbsp;Vlissides.
+<BR><EM>Design Patterns: Elements of Reusable Object-Oriented Software</EM>.
+<BR>Professional Computing. Addison-Welsey, 1995.
+
+<P></P><DT><A NAME="george93:graphtheory">13</A>
+<DD>
+A.&nbsp;George, J.&nbsp;R. Gilbert, and J.&nbsp;W. Liu, editors.
+<BR><EM>Graph Theory and Sparse Matrix Computation</EM>.
+<BR>Springer-Verlag New York, Inc, 1993.
+
+<P></P><DT><A NAME="george81:__sparse_pos_def">14</A>
+<DD>
+A.&nbsp;George and J.&nbsp;W.-H. Liu.
+<BR><EM>Computer Solution of Large Sparse Positive Definite Systems</EM>.
+<BR>Computational Mathematics. Prentice-Hall, 1981.
+
+<P></P><DT><A NAME="graham85">15</A>
+<DD>
+R.&nbsp;Graham and P.&nbsp;Hell.
+<BR>On the history of the minimum spanning tree problem.
+<BR><EM>Annals of the History of Computing</EM>, 7(1):43-57, 1985.
+
+<P></P><DT><A NAME="hart68">16</A>
+<DD>
+P.&nbsp;E. Hart, N.&nbsp;J. Nilsson, and B.&nbsp;Raphael.
+<BR>A formal basis for the heuristic determination of minimum cost paths.
+<BR><EM>IEEE Transactions on Systems Science and Cybernetics</EM>,
+  4(2):100-107, 1968.
+
+<P></P><DT><A NAME="kruskal56">18</A>
+<DD>
+J.&nbsp;B. Kruskal.
+<BR>On the shortest spanning subtree of a graph and the traveling
+  salesman problem.
+<BR>In <EM>Proceedings of the American Mathematical Sofiety</EM>, volume&nbsp;7,
+  pages 48-50, 1956.
+
+<P></P><DT><A NAME="kuehl96:_design_patterns_for_graph_algo">19</A>
+<DD>
+D.&nbsp;K&#252;hl.
+<BR>Design patterns for the implementation of graph algorithms.
+<BR>Master's thesis, Technische Universit&#228;t Berlin, July 1996.
+
+<P></P><DT><A NAME="lawler76:_comb_opt">20</A>
+<DD>
+E.&nbsp;L. Lawler.
+<BR><EM>Combinatorial Opimization: Networks and Matroids</EM>.
+<BR>Holt, Rinehart, and Winston, 1976.
+
+<P></P><DT><A NAME="LIU:MMD">21</A>
+<DD>
+J.&nbsp;W.&nbsp;H. Liu.
+<BR>Modification of the minimum-degree algorithm by multiple elimination.
+<BR><EM>ACM Transaction on Mathematical Software</EM>, 11(2):141-153, 1985.
+
+<P></P><DT><A NAME="mehlhorn99:_leda">22</A>
+<DD>
+K.&nbsp;Mehlhorn and S.&nbsp;Näher.
+<BR><EM>The LEDA Platform of Combinatorial and Geometric Computing</EM>.
+<BR>Cambridge University Press, 1999.
+
+<P></P><DT><A NAME="meyer88:_object_soft_const">23</A>
+<DD>
+B.&nbsp;Meyer.
+<BR><EM>Object-oriented Software Construction</EM>.
+<BR>Prentice Hall International Series in Computer Science. Prentice
+  Hall, 1988.
+
+<P></P><DT><A NAME="myers95:_trait">24</A>
+<DD>
+N.&nbsp;C. Myers.
+<BR>Traits: a new and useful template technique.
+<BR><EM>C++ Report</EM>, June 1995.
+
+<P></P><DT><A NAME="prim57:_short">25</A>
+<DD>
+R.&nbsp;Prim.
+<BR>Shortest connection networks and some generalizations.
+<BR><EM>Bell System Technical Journal</EM>, 36:1389-1401, 1957.
+
+<P></P><DT><A NAME="saad96:imsms">26</A>
+<DD>
+Y.&nbsp;Saad.
+<BR><EM>Iterative Methods for Sparse Minear System</EM>.
+<BR>PWS Publishing Company, 1996.
+
+<P></P><DT><A NAME="tarjan83:_data_struct_network_algo">27</A>
+<DD>
+R.&nbsp;E. Tarjan.
+<BR><EM>Data Structures and Network Algorithms</EM>.
+<BR>Society for Industrial and Applied Mathematics, 1983.
+
+<P></P><DT><A NAME="parter61:_gauss">28</A>
+<DD>
+Seymour Parter.
+<BR><EM>The use of linear graphs in Gauss elimination</EM>.
+<BR>SIAM Review, 1961 3:119-130.
+
+<P></P><DT><A NAME="matula72:_graph_theory_computing">29</A>
+<DD>
+D. Matula, G. Marble, and J. Isaacson
+<BR><EM>Graph coloring algorithms in Graph Theory and
+Computing</EM>.<BR>
+Academic Press, pp.104-122, 1972.
+
+<P></P><DT><A NAME="garey79:computers-and-intractability">30</a>
+<DD>
+M.R. Garey and D.S. Johnson<BR>
+<EM>Computers and Intractibility: A Guide to the Theory of
+NP-Completeness</EM><BR>
+W.H. Freeman, New York, 1979.
+
+<P></P><DT><A NAME="welsch67">31</a>
+<DD>D. Welsch and M. B. Powel<BR>
+<EM>An upper bound for the chromatic number of a graph and its
+application to timetabling problems</EM>
+Computer Journal, 10:85-86, 1967.
+
+<P></P><DT><A NAME="brelaz79:_new">32</a>
+<DD>D. Br'elaz<BR>
+<EM>New methods to color the vertices of a graph</EM><br>
+Communications of the ACM, vol. 22, 1979, pp. 251-256.
+
+<P></P><DT><A NAME="heber99:_saw">33</a>
+<DD>G. Heber, R. Biswas, G.R. Gao<BR>
+<EM>Self-Avoiding Walks over Adaptive Unstructured Grids</EM><br>
+Parallel and Distributed Processing, LNCS 1586,
+Springer-Verlag, 1999, pp. 968-977
+
+
+<P></P><DT><A NAME="ng-raghavan">34</a>
+<DD>Esmond G. Ng amd Padma Raghavan<BR>
+<EM>Performance of greedy ordering heuristics for sparse {C}holesky factorization</EM><br>
+SIAM Journal on Matrix Analysis and Applications (To appear)
+
+<P></P><DT><A NAME="George:evolution">35</a>
+<DD>Alan George and Joseph W. H. Liu<BR>
+<EM>The Evolution of the Minimum Degree Ordering Algorithm</EM><br>
+SIAM Review, March 1989, vol. 31, num. 1, pp. 1-19.
+
+<P></P><DT><A NAME="ford56:_maxim">36</a>
+<DD>L. R. Ford and D. R. Fulkerson<BR>
+<EM>Maximal flow through a network.</EM><br>
+Can. Journal of Mathematics 1956 pp.399-404
+
+<P></P><DT><A NAME="goldberg85:_new_max_flow_algor">37</a>
+<DD>A. V. Goldberg<BR>
+<EM>A New Max-Flow Algorithm.</EM><br>
+MIT Tehnical report MIT/LCS/TM-291, 1985.
+
+<P></P><DT><A NAME="karzanov74:_deter">38</a>
+<DD>A. V. Karzanov<BR>
+<EM>Determining the maximal flow in a network by the method of preflows.</EM><br>
+Sov. Math. Dokl. 1974
+
+<P></P><DT><A NAME="ahuja93:_network_flows">39</a>
+<DD>Ravindra K. Ahuja and Thomas L. Magnanti and James B. Orlin<BR>
+<EM>Network Flows: Theory, Algorithms, and Applications.</EM><br>
+Prentice Hall, 1993.
+
+<P></P><DT><A NAME="edmonds72:_improvements_netflow">40</a>
+<DD>Jack Edmonds and Richard M. Karp<BR>
+<EM>Theoretical improvements in the algorithmic efficiency for network flow problems.</EM><br>
+Journal of the ACM, 1972 19:248-264
+
+<P></P><DT><A NAME="tarjan72:dfs_and_linear_algo">41</a>
+<DD>Robert E. Tarjan<BR>
+<EM>Depth first search and linear graph algorithms.</EM><br>
+SIAM Journal on Computing, 1(2):146-160, 1972
+
+<P></P><DT><A NAME="eppstein97:dynamic_graph">42</a>
+<DD>David Eppstein, Zvi Galil, and Giuseppe F. Italiano<BR>
+<EM>Dynamic Graph Algorithms.</EM><br>
+Chapter 22, CRC Handbook of Algorithms and Theory of Computation, 1997. 
+
+<P></P><DT><A NAME="cuthill69:reducing_bandwith">43</a>
+<DD>E. Cuthill and J. McKee<BR>
+<EM>Reducing the bandwidth of sparse symmetric matrices.</EM><br>
+Proceedings of the 24th National Conference of the ACM, 1969.
+
+<P></P><DT><A NAME="liu75:anal_cm_rcm">44</a>
+<DD>J. Liu and A. Sherman<BR>
+<EM>Comparative analysis of the Cuthill-Mckee and the reverse
+Cuthill-Mckee ordering algorithms for sparse matrices.</EM><br>
+SIAM Journal of Numerical Analysis. 13 (1975), pp. 198-213.
+
+<P></P><DT><A NAME="george71:fem">45</a>
+<DD>Alan George<BR>
+<EM>Computer implementation of the finite element method</EM><br>
+Technical Report STAN-CS-208, Stanford University (1971).
+
+<P></P><DT><A NAME="fortin96:_graph_iso_prob">46</a>
+<DD>Scott Fortin<BR>
+<EM>The Graph Isomorphism Problem</EM><br>
+TR 96-20, Dept. of Computer Science, University of Alberta (1996)
+
+<P></P><DT><A NAME="mckay81:_pract_graph_iso">47</a>
+<DD>Brendan D. McKay<BR>
+<EM>Practical Graph Isomorphism</EM><br>
+Congressus Numerantium (1981)
+
+<P></P><DT><A NAME="reingold77:_combin_algo">48</a>
+<DD>Reingold, Nievergelt, and Deo<BR>
+<EM>Combinatorial Algorithms: Theory and Practice</EM><br>
+Prentice Hall (1977)
+
+<P></P><DT><A NAME="moore59">49</a>
+<DD>Edward Moore<BR>
+<EM>The shortest path through a maze</EM><br>
+International Symposium on the Theory of Switching (1959)<br>
+Harvard University Press
+
+<P></P><DT><A NAME="nuutila95">50</a>
+<DD>E. Nuutila<BR>
+<EM>Efficient transitive closure computation in large digraphs</EM><br>
+PhD Thesis, Helsinki University of Technology, 1995. <br>
+Acta Polytechnica Scandinavica, Mathematics and Computing in
+Engineering Series, No. 74.
+
+<P></P><DT><A NAME="goral79">51</a>
+<DD>A. Goralcikova and V. Koubek<BR>
+<EM>A reduct and closure algorithm for graphs</EM><br>
+In Mathematical Foundations of Computer Science, <br>
+volume 74 of Lecture Notes in Computer Science, pages 301-307. <br>
+Springer-Verlag, 1979
+
+<P></P><DT><A NAME="simon86">52</a>
+<DD>Klaus Simon<BR>
+<EM>An Improved Algorithm for Transitive Closure on Acyclic Digraphs</EM><br>
+Theoretical Computer Science 58<br>
+Automata, Languages and Programming, 376-386, 1986
+
+<P></P><DT><A NAME="purdom70">53</a>
+<DD>P. Purdom<BR>
+<EM>A Transitive Closure Algorithm</EM><br>
+BIT, 10, 1970, pp. 76-94.
+
+<p></p><dt><a name="brandes01">54</a>
+<dd>Ulrik Brandes<br>
+<em><a href="http://ella.slis.indiana.edu/~katy/L579/brandes.pdf">A 
+            Faster Algorithm for Betweenness Centrality</a></em><br>
+Journal of Mathematical Sociology 25 (2):163-177, 2001.
+
+<p></p><dt><a name="freeman77">55</a>
+<dd>Lindon C. Freeman<br>
+<em>A Set of Measures of Centrality Based on Betweenness</em><br>
+Sociometry 40, pp. 35-41, 1977.
+
+<p></p><dt><a name="anthonisse71">56</a>
+<dd>J.M. Anthonisse<br>
+<em>The rush in a directed graph.</em><br>
+Technical Report BN9/71, Stichting Mahtematisch Centrum, Amsterdam, 1971.
+
+<p></p><dt><a name="kamada89">57</a>
+<dd>T. Kamada and S. Kawai<br>
+<em>An algorithm for drawing general undirected graphs.</em><br>
+Information Processing Letters, 31, pp. 7-15, 1989. 
+
+<p></p><dt><a name="fruchterman91">58</a>
+<dd>T. Fruchterman and E. Reingold<br>
+  <em>Graph drawing by force-directed placement.</em><br>
+Software--Practice &amp; Experience, 21 (11), pp. 1129-1164, 1991.
+
+<p></p><dt><a name="coleman83">59</a>
+<dd>Thomas F. Coleman and Jorge J. More<br>
+  <em>Estimation of sparse Jacobian
+   matrices and graph coloring problems.</em><br>
+  Journal of Numerical Analasis V20, pp. 187-209, 1983.
+
+<p></p><dt><a name="gursoy00">60</a>
+<dd>Attila G&uuml;rsoy and Murat Atun<br>
+  <em>Neighborhood Preserving Load Balancing: A Self-Organizing Approach</em>
+  <br>
+  Euro-Par Parallel Processing, LNCS 1900, pp. 324-41, 2000.
+
+<p></p><dt><a name="driscoll88">61</a>
+<dd>James R. Driscoll, Harold N. Gabow, Ruth Shrairman, and Robert E. Tarjan<br>
+  <em>Relaxed Heaps: An alternative for Fibonacci Heaps with applications to parallel computation.</em><br>
+  Communications of the ACM, 31 (11), pp. 1343-1354, November 1988.
+
+<p></p><dt><a name="king70">62</a>
+<dd>King, I. P.<br>
+<em>An automatic reordering scheme for simultaneous equations derived from network analysis.</em><br>
+Int. J. Numer. Methods Engrg. 2, pp. 523-533, 1970.
+
+<p></p><dt><a name="palmer2000">63</a>
+<dd>C. Palmer and J. Steffan<br>
+<em>Generating Network Topologies That Obey Power Laws</em><br>
+Proceedings of GLOBECOM. November, 2000.
+
+<p></p><dt><a name="edmonds65">64</a>
+<dd>J. Edmonds<br>
+<em>Paths, trees, and flowers</em><br>
+Canadian Journal of Mathematics 17 (1965), pp. 449-467.
+
+<p></p><dt><a name="lengauer-tarjan79">65</a>
+<dd>Thomas Lengauer and Robert Endre Tarjan<br>
+<em>A fast algorithm for finding dominators in a flowgraph</em><br>
+ACM Transactions on Programming Language and Systems, 1(1):121-141, 1979.
+
+<p></p><dt><a name="muchnick97">66</a>
+<dd>Steven S. Muchnick<br>
+<em>Advanced Compiler Design and Implementation</em><br>
+Morgan Kaufmann Publishers, San Fransisco, 1997.
+
+<p></p><dt><a name="appel98">67</a>
+<dd>Andrew W. Appel<br>
+<em>Modern Compiler Implementation in JAVA</em><br>
+Cambridge University Press, 1998.
+
+<p></p><dt><a name="kolmogorov03">68</a>
+<dd>Vladimir Kolmogorov<br>
+<em>Graph Based Algorithms for Scene Reconstruction from Two or More Views</em><br>
+PhD thesis, Cornell University, September 2003.
+
+<p></p><dt><a name="boykov-kolmogorov04">69</a>
+  <dd>Yuri Boykov and Vladimir Kolmogorov<br>
+    <em><a href="http://www.csd.uwo.ca/faculty/yuri/Abstracts/pami04-abs.html">An Experimental Comparison of Min-Cut/Max-Flow Algorithms for Energy Minimization in Vision</a></em><br>
+    In <em>IEEE Transactions on Pattern Analysis and Machine Intelligence</em>, vol. 26, no. 9, pp. 1124-1137, Sept. 2004.
+
+<p></p><dt><a name="boyermyrvold04">70</a>
+<dd>John M. Boyer and Wendy J. Myrvold<br>
+<em><a href="http://www.emis.de/journals/JGAA/accepted/2004/BoyerMyrvold2004.8.3.pdf">
+On the Cutting Edge: Simplified O(n) Planarity by Edge Addition</a>
+</em><br>
+Journal of Graph Algorithms and Applications, 8(2): 241-273, 2004.
+
+<p></p><dt><a name="chrobakpayne95">71</a>
+<dd>M. Chrobak, T. Payne<br>
+<em>
+A Linear-time Algorithm for Drawing a Planar Graph on the Grid
+</em><br>
+Information Processing Letters 54: 241-246, 1995.
+
+<p></p><dt><a name="defraysseixpachpollack90">72</a>
+<dd>H. de Fraysseix, J. Pach, R. Pollack<br>
+<em>
+How to Draw a Planar Graph on a Grid
+</em><br>
+Combinatorica 10: 41-51, 1990.
+
+<P></P><DT><A NAME="wilson96generating">73</A>
+<DD>
+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>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 

doc/biconnected_components.html

@@ -0,0 +1,263 @@
+<HTML>
+<!--
+     Copyright 2001-2004 The Trustees of Indiana University.
+    
+     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)
+    
+      Authors: Douglas Gregor
+               Jeremy Siek
+               Andrew Lumsdaine
+  -->
+<Head>
+<Title>Boost Graph Library: Biconnected Components and Articulation Points</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<h1>
+<TT>
+<img src="figs/python.gif" alt="(Python)"/>
+<A NAME="sec:biconnected-components">biconnected_components
+</A>
+</TT>
+and 
+<tt>articulation_points</tt>
+</h1>
+
+<PRE>
+<i>// named parameter version</i>
+template &lt;typename Graph, typename ComponentMap, typename OutputIterator,
+          typename P, typename T, typename R&gt;
+std::pair&lt;std::size_t, OutputIterator&gt;
+biconnected_components(const Graph& g, ComponentMap comp, OutputIterator out, 
+                       const bgl_named_params&lt;P, T, R&gt;&amp; params)
+
+template &lt;typename Graph, typename ComponentMap,
+          typename P, typename T, typename R&gt;
+std::size_t
+biconnected_components(const Graph& g, ComponentMap comp, 
+                       const bgl_named_params&lt;P, T, R&gt;&amp; params)
+
+template &lt;typename Graph, typename OutputIterator, 
+          typename P, typename T, typename R&gt;
+OutputIterator articulation_points(const Graph& g, OutputIterator out, 
+                                   const bgl_named_params&lt;P, T, R&gt;&amp; params)
+
+<i>// non-named parameter version</i>
+template &lt;typename Graph, typename ComponentMap, typename OutputIterator,
+          typename DiscoverTimeMap, typename LowPointMap&gt;
+std::pair&lt;std::size_t, OutputIterator&gt;
+biconnected_components(const Graph& g, ComponentMap comp, OutputIterator out, 
+                       DiscoverTimeMap discover_time, LowPointMap lowpt);
+
+template &lt;typename Graph, typename ComponentMap, typename OutputIterator&gt;
+std::pair&lt;std::size_t, OutputIterator&gt;
+biconnected_components(const Graph& g, ComponentMap comp, OutputIterator out);
+
+template &lt;typename Graph, typename ComponentMap&gt;
+std::size_t biconnected_components(const Graph& g, ComponentMap comp);
+<a name="sec:articulation_points">
+template &lt;typename Graph, typename OutputIterator&gt;
+OutputIterator articulation_points(const Graph& g, OutputIterator out);
+</PRE>
+
+<P>
+A connected graph is <i>biconnected</i> if the removal of any single
+vertex (and all edges incident on that vertex) can not disconnect the
+graph. More generally, the biconnected components of a graph are the
+maximal subsets of vertices such that the removal of a vertex from a
+particular component will not disconnect the component. Unlike
+connected components, vertices may belong to multiple biconnected
+components: those vertices that belong to more than one biconnected
+component are called <em>articulation points</em> or, equivalently,
+<em>cut vertices</em>. Articulation points are vertices whose removal
+would increase the number of connected components in the graph. Thus,
+a graph without articulation points is biconnected. The following
+figure illustrates the articulation points and biconnected components
+of a small graph:
+
+<p><center><img src="figs/biconnected.png"></center>
+
+<p>Vertices can be present in multiple biconnected components, but each
+edge can only be contained in a single biconnected component. The
+output of the <tt>biconnected_components</tt> algorithm records the
+biconnected component number of each edge in the property map
+<tt>comp</tt>. Articulation points will be emitted to the (optional)
+output iterator argument to <tt>biconnected_components</tt>, or can be
+computed without the use of a biconnected component number map via
+<tt>articulation_points</tt>. These functions return the number of
+biconnected components, the articulation point output iterator, or a
+pair of these quantities, depending on what information was
+recorded.
+
+<p>The algorithm implemented is due to Tarjan [<a href="bibliography.html#tarjan72:dfs_and_linear_algo">41</a>].
+
+<H3>Where Defined</H3>
+
+<P>
+<a href="../../../boost/graph/biconnected_components.hpp"><TT>boost/graph/biconnected_components.hpp</TT></a>
+
+
+<h3>Parameters</h3>
+
+IN: <tt>const Graph&amp; g</tt>
+<blockquote>
+An undirected graph. The graph type must be a model of <a
+href="VertexListGraph.html">Vertex List Graph</a> and <a
+href="IncidenceGraph.html">Incidence Graph</a>.<br>
+<b>Python</b>: The parameter is named <tt>graph</tt>.
+</blockquote>
+
+OUT: <tt>ComponentMap c</tt>
+<blockquote>
+The algorithm computes how many biconnected components are in the graph,
+and assigning each component an integer label. The algorithm then
+records which component each edge in the graph belongs to by
+recording the component number in the component property map. The
+<tt>ComponentMap</tt> type must be a model of <a
+href="../../property_map/doc/WritablePropertyMap.html">Writable Property
+Map</a>. The value type should be an integer type, preferably the same
+as the <tt>edges_size_type</tt> of the graph. The key type must be
+the graph's edge descriptor type.<br>
+<b>Default</b>: <tt>dummy_property_map</tt>.<br>
+  <b>Python</b>: Must be an <tt>edge_int_map</tt> for the graph.<br>
+  <b>Python default</b>: <tt>graph.get_edge_int_map("bicomponent")</tt>
+</blockquote>
+
+OUT: <tt>OutputIterator out</tt>
+<blockquote>
+The algorithm writes articulation points via this output
+iterator and returns the resulting iterator.<br>
+<b>Default</b>: a dummy iterator that ignores values written to it.<br>
+
+<b>Python</b>: this parameter is not used in Python. Instead, both
+algorithms return a Python <tt>list</tt> containing the articulation
+points.
+</blockquote>
+
+<h3>Named Parameters</h3>
+
+IN: <tt>vertex_index_map(VertexIndexMap i_map)</tt> 
+<blockquote>
+  This maps each vertex to an integer in the range <tt>[0,
+    num_vertices(g))</tt>. The type 
+  <tt>VertexIndexMap</tt> must be a model of
+  <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a>. The value type of the map must be an
+  integer type. The vertex descriptor type of the graph needs to be
+  usable as the key type of the map.<br>
+  <b>Default:</b> <tt>get(vertex_index, g)</tt><br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+UTIL/OUT: <tt>discover_time_map(DiscoverTimeMap discover_time)</tt>
+<blockquote>
+  The discovery time of each vertex in the depth-first search. The
+  type <tt>DiscoverTimeMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a>. The value type of the map must be an integer
+  type. The vertex descriptor type of the graph needs to be usable as
+  the key type of the map.<br>
+<b>Default</b>: an <a
+  href="../../property_map/doc/iterator_property_map.html">
+  </tt>iterator_property_map</tt></a> created from a
+  <tt>std::vector</tt> of <tt>vertices_size_type</tt> of size
+  <tt>num_vertices(g)</tt> and using <tt>get(vertex_index, g)</tt> for
+  the index map.<br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+UTIL/OUT: <tt>lowpoint_map(LowPointMap lowpt)</tt>
+<blockquote>
+  The low point of each vertex in the depth-first search, which is the
+  smallest vertex reachable from a given vertex with at most one back
+  edge.  The type <tt>LowPointMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a>. The value type of the map must be an integer
+  type. The vertex descriptor type of the graph needs to be usable as
+  the key type of the map.<br>
+<b>Default</b>: an <a
+  href="../../property_map/doc/iterator_property_map.html">
+  </tt>iterator_property_map</tt></a> created from a
+  <tt>std::vector</tt> of <tt>vertices_size_type</tt> of size
+  <tt>num_vertices(g)</tt> and using <tt>get(vertex_index, g)</tt> for
+  the index map.<br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+UTIL/OUT: <tt>predecessor_map(PredecessorMap p_map)</tt> 
+<blockquote>
+  The predecessor map records the depth first search tree. 
+  The <tt>PredecessorMap</tt> type
+  must be a <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a> whose key and value types are the same as the vertex
+  descriptor type of the graph.<br>
+  <b>Default:</b> an <a
+  href="../../property_map/doc/iterator_property_map.html">
+  </tt>iterator_property_map</tt></a> created from a
+  <tt>std::vector</tt> of <tt>vertex_descriptor</tt> of size
+  <tt>num_vertices(g)</tt> and using <tt>get(vertex_index, g)</tt> for
+  the index map.<br>
+
+  <b>Python</b>: Must be a <tt>vertex_vertex_map</tt> for the graph.<br>
+</blockquote>
+
+IN: <tt>visitor(DFSVisitor vis)</tt>
+<blockquote>
+  A visitor object that is invoked inside the algorithm at the
+  event-points specified by the <a href="./DFSVisitor.html">DFS
+  Visitor</a> concept. The visitor object is passed by value <a
+  href="#1">[1]</a>. <br> <b>Default:</b>
+  <tt>dfs_visitor&lt;null_visitor&gt;</tt><br>
+
+  <b>Python</b>: The parameter should be an object that derives from
+  the <a href="DFSVisitor.html#python"><tt>DFSVisitor</tt></a> type of
+  the graph.
+</blockquote>
+
+<H3>Complexity</H3>
+
+<P>
+The time complexity for the biconnected components and articulation
+points algorithms
+<i>O(V + E)</i>.
+
+<P>
+
+<H3>Example</H3>
+
+<P> The file <a
+href="../example/biconnected_components.cpp"><tt>examples/biconnected_components.cpp</tt></a>
+contains an example of calculating the biconnected components and
+articulation points of an undirected graph.
+
+<h3>Notes</h3>
+
+<p><a name="1">[1]</a> 
+  Since the visitor parameter is passed by value, if your visitor
+  contains state then any changes to the state during the algorithm
+  will be made to a copy of the visitor object, not the visitor object
+  passed in. Therefore you may want the visitor to hold this state by
+  pointer or reference.
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2004</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana
+University (<A
+HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
+<a href="http://www.boost.org/people/doug_gregor.html">Doug Gregor</a>, Indiana University
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 

doc/biconnected_components.w

@@ -0,0 +1,387 @@
+\documentclass[11pt]{report}
+
+
+\usepackage[leqno]{amsmath}
+\usepackage{amsfonts}
+\usepackage{amssymb}
+\usepackage{amsthm}
+\usepackage{latexsym}     
+\usepackage{jweb}
+\usepackage{times}
+\usepackage{graphicx}
+\usepackage[nolineno]{lgrind}
+
+\newif\ifpdf
+\ifx\pdfoutput\undefined
+   \pdffalse
+\else
+   \pdfoutput=1
+   \pdftrue
+\fi
+
+\ifpdf
+  \usepackage[
+              pdftex,
+              colorlinks=true, % change to true for the electronic version
+              linkcolor=blue,filecolor=blue,pagecolor=blue,urlcolor=blue
+              ]{hyperref}
+  \newcommand{\myhyperref}[2]{\hyperref[#1]{#2}}
+\fi
+
+\newcommand{\mtlfig}[2]{\centerline{\includegraphics*[#2]{#1.pdf}}}
+
+\newcommand{\Path}{\rightsquigarrow}
+\newcommand{\ancestor}{\overset{T}{\rightsquigarrow}}
+\newcommand{\descendant}{\ancestor^{-1}}
+\newcommand{\backedge}{\overset{B}{\rightarrow}}
+\newcommand{\edge}{\rightarrow}
+\DeclareMathOperator{\suchthat}{s.t.}
+
+\newcommand{\code}[1]{{\small{\em \textbf{#1}}}}
+\newcommand{\concept}[1]{\textsf{#1}}
+
+\begin{document}
+
+\title{An Implementation of Biconnected Components}
+\author{Jeremy Siek}
+
+\maketitle
+
+\section{Introduction}
+
+This paper documents the implementation of the
+\code{biconnected\_components()} function of the Boost Graph
+Library. The function was implemented by Jeremy Siek.
+
+The algorithm used to implement the \code{biconnected\_components()}
+function is the one based on depth-first search described
+by Tarjan~\cite{tarjan72:dfs_and_linear_algo}.
+
+An undirected graph $G = (V,E)$ is \emph{biconnected} if for each
+triple of distinct vertices $v, w, a \in V$ there is a path $p : v
+\Path w$ such that $a$ is not on the path $p$.  An \emph{articulation
+point} of $G = (V,E)$ is a vertex $a \in V$ where there are two other
+distinct vertices $v,w \in V$ such that $a$ is on any path $p:v \Path
+w$ and there is at least one such path. If $a$ were to be removed from
+$G$, then $v$ and $w$ would no longer be reachable from each other.
+So articulation points act as bridges between biconnected components;
+the only path from one biconnected component to another is through an
+articulation point.
+
+The algorithm finds articulation points based on information provided
+by depth-first search. During a DFS, we label each vertex $v \in G$
+with its discover time, denoted $d[v]$.  During the DFS we also
+compute the $lowpt(v)$, which is the smallest (in terms of discover
+time) vertex reachable from $v$ by traversing zero or more DFS-tree
+edges followed by at most one back edge. Tree edges and back edges can
+be identified based on discover time because for tree edge $(u,v)$ we
+have $d[u] < d[v]$ and for back edge $(u,v)$ we have $d[u] >
+d[v]$. The $lowpt(v)$ is computed for $v$ by taking the minimum
+$lowpt$ of the vertices to which $v$ is adjacent.  The $lowpt(v)$ is
+computed after the recursive DFS call so the $lowpt$ has already been
+computed for the adjacent vertices by the time $lowpt(v)$ is computed.
+
+Now it turns out that $lowpt$ can be used to identify articulation
+points. Suppose $a,v,w$ are distinct vertices in $G$ such that $(a,v)$
+is a tree edge and $w$ is not a descendant of $v$. If $d[lowpt(v)]
+\geq d[a]$, then $a$ is an articulation point and removal of $a$
+disconnects $v$ and $w$. The reason this works is that if $d[lowpt(v)]
+\geq d[a]$, then we know all paths starting from $v$ stay within the
+sub-tree $T_v$ rooted at $v$. If a path were to escape from the
+sub-tree, then consider the first vertex $w$ in that path outside of
+$T_v$.  $v \Path w$ must be considered for $lowpt(v)$, so $d[lowpt(v)]
+< d[w]$. Now $d[w] < d[a]$ due the structure of the DFS, so
+transitively $d[lowpt(v)] < d[a]$.
+
+\section{The Implementation}
+
+The implementation consists of a recursive DFS-like function named
+\code{biconnect()} and the public interface function
+\code{biconnected\-\_components()}. The \code{Graph} type must be a
+model of \concept{VertexListGraph} and of \concept{IncidenceGraph}.
+The result of the algorithm is recorded in the \code{ComponentMap},
+which maps edges to the biconnected component that they belong to
+(components are labeled with integers from zero on up).  The
+\code{ComponentMap} type must be a model of
+\concept{WritablePropertyMap}, which the graph's
+\code{edge\-\_descriptor} type as the key type and an unsigned integer
+type as the value type. We do not record which component each vertex
+belongs to because vertices that are articulation points belong to
+multiple biconnected components.  The number of biconnected components
+is returned in the \code{num\_components} parameter. The
+\code{discover\_time} parameter is used internally to keep track of
+the DFS discover time for each vertex. It must be a
+\concept{ReadWritePropertyMap} with the graph's
+\code{vertex\_\-descriptor} type as the key type and an unsigned
+integer as the value type. The \code{lowpt} parameter is used
+internally to keep track of the $d[lowpt(v)]$ for each vertex $v$.  It
+must be a \concept{ReadWritePropertyMap} with the graph's
+\code{vertex\_\-descriptor} type is the key type and the value type is
+the same unsigned integer type as the value type in the
+\code{discover\-\_time} map.
+
+@d Biconnected Components Algorithm
+@{
+namespace detail {
+  @<Recursive Biconnect Function@>
+}
+
+template <typename Graph, typename ComponentMap,
+  typename DiscoverTimeMap, typename LowPointMap>
+void biconnected_components
+  (typename graph_traits<Graph>::vertex_descriptor v,
+   typename graph_traits<Graph>::vertex_descriptor u,
+   const Graph& g,
+   ComponentMap comp,
+   std::size_t& num_components,
+   DiscoverTimeMap discover_time,
+   LowPointMap lowpt)
+{
+  typedef graph_traits<Graph>::vertex_descriptor vertex_t;
+  typedef graph_traits<Graph>::edge_descriptor edge_t;
+  @<Concept checking of type parameters@>
+  typedef typename property_traits<DiscoverTimeMap>::value_type D;
+  num_components = 0;
+  std::size_t dfs_time = 0;
+  std::stack<edge_t> S;
+  @<Initialize discover times to infinity@>
+  @<Process each connected component@>
+}
+@}
+
+\noindent In the following code we use the Boost Concept Checking
+Library to provide better error messages in the event that the user
+makes a mistake in the kind of parameter used in the function
+template.
+
+@d Concept checking of type parameters
+@{
+BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<ComponentMap, edge_t> ));
+BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<DiscoverTimeMap, vertex_t> ));
+BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<LowPointMap, vertex_t> ));
+@}
+
+The first step of the algorithm is to initialize the discover times of
+all the vertices to infinity. This marks the vertices as undiscovered.
+
+@d Initialize discover times to infinity
+@{
+typename graph_traits<Graph>::vertex_iterator wi, wi_end;
+std::size_t infinity = std::numeric_limits<std::size_t>::max();
+for (tie(wi, wi_end) = vertices(g); wi != wi_end; ++wi)
+  put(discover_time, *wi, infinity);
+@}
+
+\noindent Next we invoke \code{biconnect()} on every vertex in the
+graph, making sure that all connected components within the graph are
+searched (\code{biconnect()} only processes a single connected
+component).
+
+@d Process each connected component
+@{
+for (tie(wi, wi_end) = vertices(g); wi != wi_end; ++wi)
+  if (get(discover_time, *wi) == std::numeric_limits<D>::max())
+    detail::biconnect(*wi, *wi, true,
+                      g, comp, num_components,
+                      discover_time, dfs_time, lowpt, S);
+@}
+
+The recursive \code{biconnect()} function is shown below.  The
+\code{v} parameter is where the DFS is started.  The \code{u}
+parameter is the parent of \code{v} in the DFS-tree if \code{at\_top
+== false} or if \code{at\_top == true} the \code{u} is not used.
+\code{S} is a stack of edges that is used to collect all edges in a
+biconnected component. The way this works is that on ``the way down''
+edges are pushed into the stack.  ``On the way back up'', when an
+articulation point $v$ is found (identified because $d[lowpt(w)] \geq
+d[v]$) we know that a contiguous portion of the stack (starting at the
+top) contains the edges in the sub-tree $T_v$ which is the biconnected
+component.  We therefore pop these edges off of the stack (until we
+find an edge $e$ where $d[lowpt(source(e))] < d[w]$) and mark them as
+belonging to the same component. The code below also includes the
+bookkeeping details such as recording the discover times and computing
+$lowpt$. When a back edge $(v,w)$ is encountered, we do not use
+$lowpt(w)$ in calculating $lowpt(v)$ since $lowpt(w)$ has not yet been
+computed. Also, we ignore the edge $(v,w)$ if $w$ is the parent of $v$
+in the DFS-tree, meaning that $(w,v)$ has already been examined and
+categorized as a tree edge (not a back edge).
+
+@d Recursive Biconnect Function
+@{
+template <typename Graph, typename ComponentMap,
+  typename DiscoverTimeMap, typename LowPointMap, typename Stack>
+void biconnect(typename graph_traits<Graph>::vertex_descriptor v,
+              typename graph_traits<Graph>::vertex_descriptor u,
+              bool at_top,
+              const Graph& g,
+              ComponentMap comp,
+              std::size_t& c,
+              DiscoverTimeMap d,
+              std::size_t& dfs_time,
+              LowPointMap lowpt,
+              Stack& S)
+{
+  typedef typename graph_traits<Graph>::vertex_descriptor vertex_t;
+  typedef typename property_traits<DiscoverTimeMap>::value_type D;
+  D infinity = std::numeric_limits<D>::max();
+  put(d, v, ++dfs_time);
+  put(lowpt, v, get(d, v));
+  typename graph_traits<Graph>::out_edge_iterator ei, ei_end;
+  for (tie(ei, ei_end) = out_edges(v, g); ei != ei_end; ++ei) {
+    vertex_t w = target(*ei, g);
+    if (get(d, w) == infinity) {
+      S.push(*ei);
+      biconnect(w, v, false, g, comp, c, d, dfs_time, lowpt, S);
+      put(lowpt, v, std::min(get(lowpt, v), get(lowpt, w)));
+      if (get(lowpt, w) >= get(d, v)) {
+        @<Record the biconnected component@>
+      }
+    } else if (get(d, w) < get(d, v) && (!at_top && w != u)) {
+      S.push(*ei);
+      put(lowpt, v, std::min(get(lowpt, v), get(d, w)));
+    }
+  }
+}
+@}
+
+\noindent The following is the code for popping the edges of sub-tree
+$T_v$ off of the stack and recording them as being in the same
+biconnected component.
+
+@d Record the biconnected component
+@{
+while (d[source(S.top(), g)] >= d[w]) {
+  put(comp, S.top(), c);
+  S.pop();
+}
+put(comp, S.top(), c);
+S.pop();
+++c;
+@}
+
+
+\section{Appendix}
+
+@o biconnected-components.hpp
+@{
+// Copyright (c) Jeremy Siek 2001
+//
+// Permission to use, copy, modify, distribute and sell this software
+// and its documentation for any purpose is hereby granted without fee,
+// provided that the above copyright notice appears in all copies and
+// that both that copyright notice and this permission notice appear
+// in supporting documentation.  Silicon Graphics makes no
+// representations about the suitability of this software for any
+// purpose.  It is provided "as is" without express or implied warranty.
+
+// NOTE: this final is generated by libs/graph/doc/biconnected_components.w
+
+#ifndef BOOST_GRAPH_BICONNECTED_COMPONENTS_HPP
+#define BOOST_GRAPH_BICONNECTED_COMPONENTS_HPP
+
+#include <stack>
+#include <boost/limits.hpp>
+#include <boost/graph/graph_traits.hpp>
+#include <boost/graph/graph_concepts.hpp>
+#include <boost/property_map/property_map.hpp>
+#include <boost/concept/assert.hpp>
+
+namespace boost {
+  @<Biconnected Components Algorithm@>
+} // namespace boost
+
+#endif BOOST_GRAPH_BICONNECTED_COMPONENTS_HPP
+@}
+
+Figure~\ref{fig:bcc} shows the graph used in the following example and
+the edges are labeled by biconnected component number, as computed by
+the algorithm.
+
+
+\begin{figure}[htbp]
+  \mtlfig{bcc}{width=3.0in}
+  \caption{The biconnected components.}
+  \label{fig:bcc}
+\end{figure}
+
+
+@o biconnected-components.cpp
+@{
+#include <vector>
+#include <list>
+#include <boost/graph/biconnected_components.hpp>
+#include <boost/graph/adjacency_list.hpp>
+
+namespace boost {
+  struct edge_component_t {
+    enum { num = 555 };
+    typedef edge_property_tag kind;
+  } edge_component;
+}
+
+int main()
+{
+  using namespace boost;
+  typedef adjacency_list<vecS, vecS, undirectedS,
+    no_property, property<edge_component_t, std::size_t> > graph_t;
+  typedef graph_traits<graph_t>::vertex_descriptor vertex_t;
+  graph_t g(9);
+  add_edge(0, 5, g); add_edge(0, 1, g); add_edge(0, 6, g);
+  add_edge(1, 2, g); add_edge(1, 3, g); add_edge(1, 4, g);
+  add_edge(2, 3, g);
+  add_edge(4, 5, g);
+  add_edge(6, 8, g); add_edge(6, 7, g);
+  add_edge(7, 8, g);
+
+  std::size_t c = 0;
+  std::vector<std::size_t> discover_time(num_vertices(g));
+  std::vector<vertex_t> lowpt(num_vertices(g));
+  property_map<graph_t, edge_component_t>::type
+    component = get(edge_component, g);
+  biconnected_components(0, 8, g, component,
+                         c, &discover_time[0], &lowpt[0]);
+
+  std::cout << "graph A {\n"
+            << "  node[shape=\"circle\"]\n";
+
+  graph_traits<graph_t>::edge_iterator ei, ei_end;
+  for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+    std::cout << source(*ei, g) << " -- " << target(*ei, g)
+              << "[label=\"" << component[*ei] << "\"]\n";
+  std::cout << "}\n";
+
+  return 0;
+}
+@}
+
+
+
+% \paragraph{Definition.} A \emph{palm tree} $P$ is a directed graph that 
+% consists of two disjoint sets of edges, denoted by $v \rightarrow w$
+% and $v \backedge w$ respectively, with the following properties:
+
+% \begin{enumerate}
+
+% \item The subgraph $T$ containing the edges $v \rightarrow w$ is a
+%   spanning tree of $P$.
+
+% \item $\backedge \; \subseteq \descendant$. That is, each edge of $P$
+% that is not in $T$ connects a vertex to one of its ancestors in $T$.
+% \end{enumerate}
+
+
+
+\bibliographystyle{abbrv}
+\bibliography{jtran,ggcl,optimization,generic-programming,cad}
+
+\end{document}
+
+% LocalWords:  Biconnected Siek biconnected Tarjan undirected DFS lowpt num dfs
+% LocalWords:  biconnect VertexListGraph IncidenceGraph ComponentMap namespace
+% LocalWords:  WritablePropertyMap ReadWritePropertyMap typename LowPointMap wi
+% LocalWords:  DiscoverTimeMap const comp typedef VertexListGraphConcept max ei
+% LocalWords:  IncidenceGraphConcept WritablePropertyMapConcept iterator bool
+% LocalWords:  ReadWritePropertyMapConcept hpp ifndef endif bcc cpp struct enum
+% LocalWords:  adjacency vecS undirectedS jtran ggcl

doc/boyer_myrvold.html

@@ -0,0 +1,259 @@
+<HTML>
+<!-- Copyright 2007 Aaron Windsor
+     
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+    
+  -->
+<Head>
+<Title>Boost Graph Library: Boyer-Myrvold Planarity Testing/Embedding</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1>Boyer-Myrvold Planarity Testing/Embedding</H1>
+
+<p>
+A graph is <a href="./planar_graphs.html#planar"><i>planar</i></a> if it can 
+be drawn in two-dimensional space without any of its edges crossing. Such a 
+drawing of a planar graph is called a 
+<a href="./planar_graphs.html#plane_drawing"><i>plane drawing</i></a>. Each 
+plane drawing belongs to an equivalence class called a <i>planar embedding</i>
+<a href="#1">[1]</a> that is defined by the clockwise ordering of adjacent 
+edges around each vertex in the graph. A planar embedding is a convenient 
+intermediate representation of an actual drawing of a planar graph, and many 
+planar graph drawing algorithms are formulated as functions mapping a planar 
+embedding to a plane drawing.
+<br>
+<br>
+<table align="center" class="image">
+<caption align="bottom"><h5>A planar graph (top left), along with a planar 
+embedding of that graph (bottom left) can be used to create a plane drawing 
+(right) by embedding edges around each vertex in the order in which they 
+appear in the planar embedding.
+</h5></caption>
+<tr><td>
+<img src="./figs/embedding_illustration.png">
+</td></tr>
+<tr></tr>
+<tr></tr>
+</table>
+<br>
+<p>
+The function <tt>boyer_myrvold_planarity_test</tt> implements the planarity 
+testing/embedding algorithm of Boyer and Myrvold 
+[<a href="./bibliography.html#boyermyrvold04">70</a>].
+<tt>boyer_myrvold_planarity_test</tt> returns <tt>true</tt> if the input graph 
+is planar and <tt>false</tt> otherwise. As a side-effect of this test, a planar
+embedding can be constructed if the graph is planar or a minimal set of edges 
+that form a <a href = "./planar_graphs.html#kuratowskisubgraphs">Kuratowski 
+subgraph</a> can be found if the graph is not planar.
+<tt>boyer_myrvold_planarity_test</tt> uses named parameter arguments (courtesy 
+of the <a href="../../parameter/doc/html/index.html">Boost.Parameter</a> 
+library) to specify what the function actually does. Some examples are:
+
+<ul>
+<li>Testing whether or not a graph is planar:
+<pre>
+bool is_planar = boyer_myrvold_planarity_test(g);
+</pre>
+
+<li>Computing a planar embedding for a graph if it is planar, otherwise finding
+a set of edges that forms an obstructing Kuratowski subgraph:
+<pre>
+if (boyer_myrvold_planarity_test(boyer_myrvold_params::graph = g, 
+                                 boyer_myrvold_params::embedding = embedding_pmap,  
+                                 boyer_myrvold_params::kuratowski_subgraph = out_itr
+                                 )
+    )
+{
+  //do something with the embedding in embedding_pmap
+}
+else
+{
+  //do something with the kuratowski subgraph output to out_itr
+}
+</pre>
+</ul>
+
+<p>
+The parameters passed to <tt>boyer_myrvold_planarity_test</tt> in the examples 
+above do more than just carry the data structures used for input and output - 
+the algorithm is optimized at compile time based on which parameters are 
+present. A complete list of parameters accepted and their interactions are 
+described below. 
+<p>
+<tt>boyer_myrvold_planarity_test</tt> accepts as input any undirected graph,
+even those with self-loops and multiple edges.
+However, many planar graph drawing algorithms make additional restrictions 
+on the structure of the input graph - for example, requiring that the input 
+graph is connected, biconnected, or even maximal planar (triangulated.)
+Fortunately, any planar graph on <i>n</i> vertices that lacks one of these 
+properties can be augmented with additional edges so that it satisfies that 
+property in <i>O(n)</i> time - the functions 
+<tt><a href="./make_connected.html">make_connected</a></tt>,
+<tt><a href="./make_biconnected_planar.html">make_biconnected_planar</a></tt>, 
+and <tt><a href="./make_maximal_planar.html">make_maximal_planar</a></tt> 
+exist for this purpose. If the graph drawing algorithm you're using requires, 
+say, a biconnected graph, then you must make your input graph biconnected 
+<i>before</i> passing it into <tt>boyer_myrvold_planarity_test</tt> so that the
+computed planar embedding includes these additional edges. This may require 
+more than one call to <tt>boyer_myrvold_planarity_test</tt> depending on the 
+structure of the graph you begin with, since both 
+<tt>make_biconnected_planar</tt> and <tt>make_maximal_planar</tt> require a 
+planar embedding of the existing graph as an input parameter.
+
+<p><p>
+The named parameters accepted by <tt>boyer_myrvold_planarity_test</tt> are:
+
+<ul>
+<li><b><tt>graph</tt></b> : The input graph - this is the only required 
+parameter.
+<li><b><tt>vertex_index_map</tt></b> : A mapping from vertices of the input 
+graph to indexes in the range <tt>[0..num_vertices(g))</tt>. If this parameter 
+is not provided, the vertex index map is assumed to be available as an interior
+property of the graph, accessible by calling <tt>get(vertex_index, g)</tt>.
+<li><b><tt>edge_index_map</tt></b>: A mapping from the edges of the input graph
+to indexes in the range <tt>[0..num_edges(g))</tt>. This parameter is only 
+needed if the <tt>kuratowski_subgraph</tt> argument is provided. If the 
+<tt>kuratowski_subgraph</tt> argument is provided and this parameter is not
+provided, the EdgeIndexMap is assumed to be available as an interior property 
+accessible by calling <tt>get(edge_index, g)</tt>.
+<li><b><tt>embedding</tt></b> : If the graph is planar, this will be populated 
+with a mapping from vertices to the clockwise order of neighbors in the planar 
+embedding.
+<li><b><tt>kuratowski_subgraph</tt></b> : If the graph is not planar, a minimal
+set of edges that form the obstructing Kuratowski subgraph will be written to 
+this iterator.
+</ul>
+
+These named parameters all belong to the namespace 
+<tt>boyer_myrvold_params</tt>. See below for more information on the concepts 
+required for these arguments. 
+
+<H3>Verifying the output</H3>
+
+Whether or not the input graph is planar, <tt>boyer_myrvold_planarity_test</tt>
+can produce a certificate that can be automatically checked to verify that the 
+function is working properly. 
+<p>
+If the graph is planar, a planar embedding can be produced. The
+planar embedding can be verified by passing it to a plane drawing routine 
+(such as <tt><a href="straight_line_drawing.html">
+chrobak_payne_straight_line_drawing</a></tt>) and using the function 
+<tt><a href="is_straight_line_drawing.html">is_straight_line_drawing</a></tt> 
+to verify that the resulting graph is planar.
+<p>
+If the graph is not planar, a set of edges that forms a Kuratowski subgraph in 
+the original graph can be produced. This set of edges can be passed to the 
+function <tt><a href="is_kuratowski_subgraph.html">is_kuratowski_subgraph</a>
+</tt> to verify that they can be contracted into a <i>K<sub>5</sub></i> or 
+<i>K<sub>3,3</sub></i>. <tt>boyer_myrvold_planarity_test</tt> chooses the set 
+of edges forming the Kuratowski subgraph in such a way that the contraction to 
+a <i>K<sub>5</sub></i> or <i>K<sub>3,3</sub></i> can be done by a simple 
+deterministic process which is described in the documentation to 
+<tt>is_kuratowski_subgraph</tt>.
+
+<H3>Where Defined</H3>
+
+<P>
+<a href="../../../boost/graph/boyer_myrvold_planar_test.hpp">
+<TT>boost/graph/boyer_myrvold_planar_test.hpp</TT>
+</a>
+
+<H3>Parameters</H3>
+
+IN: <tt>Graph&amp; g</tt>
+
+<blockquote>
+Any undirected graph. The graph type must be a model of 
+<a href="VertexAndEdgeListGraph.html">VertexAndEdgeListGraph</a> and 
+<a href="IncidenceGraph.html">IncidenceGraph</a>.
+</blockquote>
+
+OUT <tt>PlanarEmbedding embedding</tt>
+
+<blockquote>
+Must model the <a href="PlanarEmbedding.html">PlanarEmbedding</a> concept.
+</blockquote>
+
+IN <tt>OutputIterator kuratowski_subgraph</tt>
+
+<blockquote>
+An OutputIterator which accepts values of the type 
+<tt>graph_traits&lt;Graph&gt;::edge_descriptor</tt>
+</blockquote>
+
+IN <tt>VertexIndexMap vm</tt>
+
+<blockquote>
+A <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map
+</a> that maps vertices from <tt>g</tt> to distinct integers in the range 
+<tt>[0, num_vertices(g) )</tt><br>
+<b>Default</b>: <tt>get(vertex_index,g)</tt><br>
+</blockquote>
+
+IN <tt>EdgeIndexMap em</tt>
+
+<blockquote>
+A <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map
+</a> that maps edges from <tt>g</tt> to distinct integers in the range 
+<tt>[0, num_edges(g) )</tt><br>
+<b>Default</b>: <tt>get(edge_index,g)</tt>, but this parameter is only used if 
+the <tt>kuratowski_subgraph_iterator</tt> is provided.<br>
+</blockquote>
+
+<H3>Complexity</H3>
+
+Assuming that both the vertex index and edge index supplied take time 
+<i>O(1)</i> to return an index and there are <i>O(n)</i> 
+total self-loops and parallel edges in the graph, most combinations of 
+arguments given to 
+<tt>boyer_myrvold_planarity_test</tt> result in an algorithm that runs in time 
+<i>O(n)</i> for a graph with <i>n</i> vertices and <i>m</i> edges. The only 
+exception is when Kuratowski subgraph isolation is requested for a dense graph 
+(a graph with <i>n = o(m)</i>) - the running time will be <i>O(n+m)</i>
+<a href = "#2">[2]</a>.
+
+<H3>Examples</H3>
+
+<P>
+<ul>
+<li><a href="../example/simple_planarity_test.cpp">A simple planarity test</a>
+<li><a href="../example/kuratowski_subgraph.cpp">Isolating a Kuratowski 
+Subgraph</a>
+<li><a href="../example/straight_line_drawing.cpp">Using a planar embedding to 
+create a straight line drawing</a>
+</ul>
+
+<h3>See Also</h3>
+
+<a href="./planar_graphs.html">Planar Graphs in the Boost Graph Library</a>
+
+
+<h3>Notes</h3>
+
+<p><a name="1">[1] A planar embedding is also called a <i>combinatorial 
+embedding</i>.
+
+<p><a name="2">[2] The algorithm can still be made to run in time <i>O(n)</i> 
+for this case, if needed. <a href="planar_graphs.html#EulersFormula">Euler's 
+formula</a> implies that a planar graph with <i>n</i> vertices can have no more
+than <i>3n - 6</i> edges, which means that any non-planar graph on <i>n</i> 
+vertices has a subgraph of only <i>3n - 5</i> edges that contains a Kuratowski 
+subgraph. So, if you need to find a Kuratowski subgraph of a graph with more 
+than <i>3n - 5</i> edges in time <i>O(n)</i>, you can create a subgraph of the 
+original graph consisting of any arbitrary <i>3n - 5</i> edges and pass that 
+graph to <tt>boyer_myrvold_planarity_test</tt>.
+
+
+<br>
+<HR>
+Copyright &copy; 2007 Aaron Windsor (<a href="mailto:aaron.windsor@gmail.com">
+aaron.windsor@gmail.com</a>)
+</BODY>
+</HTML> 

doc/boykov_kolmogorov_max_flow.html

@@ -0,0 +1,395 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<HTML>
+<HEAD>
+	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=iso-8859-15">
+	<TITLE>Boost Graph Library: Boykov-Kolmogorov Maximum Flow</TITLE>
+	<META NAME="GENERATOR" CONTENT="OpenOffice.org 2.0  (Linux)">
+	<META NAME="CREATED" CONTENT="20060820;17315200">
+	<META NAME="CHANGEDBY" CONTENT="Stephan Diederich">
+	<META NAME="CHANGED" CONTENT="20060820;23125100">
+<!--
+//  Copyright (c) 2006 Stephan Diederich
+//
+//  This documentation may be used under either of the following two licences:
+//
+//    Permission is hereby granted, free of charge, to any person
+//    obtaining a copy of this software and associated documentation
+//    files (the "Software"), to deal in the Software without
+//    restriction, including without limitation the rights to use,
+//    copy, modify, merge, publish, distribute, sublicense, and/or
+//    sell copies of the Software, and to permit persons to whom the
+//    Software is furnished to do so, subject to the following
+//    conditions:
+//
+//    The above copyright notice and this permission notice shall be
+//    included in all copies or substantial portions of the Software.
+//
+//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+//    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+//    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+//    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+//    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+//    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+//    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+//    OTHER DEALINGS IN THE SOFTWARE. OF SUCH DAMAGE.
+//
+//  Or:
+//
+//    Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//    http://www.boost.org/LICENSE_1_0.txt)
+ -->
+	<STYLE>
+	<!--
+		TD P { color: #000000 }
+		H1 { color: #000000 }
+		P { color: #000000 }
+		PRE { color: #000000 }
+		H3 { color: #000000 }
+		BLOCKQUOTE { color: #000000 }
+		A:link { color: #0000ee }
+		A:visited { color: #551a8b }
+	-->
+	</STYLE>
+</HEAD>
+<BODY LANG="de-DE" TEXT="#000000" LINK="#0000ee" VLINK="#551a8b" BGCOLOR="#ffffff" DIR="LTR">
+<P><IMG SRC="../../../boost.png" NAME="Grafik1" ALT="C++ Boost" ALIGN=BOTTOM WIDTH=277 HEIGHT=86 BORDER=0>
+</P>
+<H1><A NAME="sec:boykov_kolmogorov_max_flow"></A><TT>boykov_kolmogorov_max_flow</TT>
+</H1>
+<PRE><I>// named parameter version</I>
+template &lt;class Graph, class P, class T, class R&gt;
+typename property_traits&lt;typename property_map&lt;Graph, edge_capacity_t&gt;::const_type&gt;::value_type
+boykov_kolmogorov_max_flow(Graph&amp; g,
+   typename graph_traits&lt;Graph&gt;::vertex_descriptor src,
+   typename graph_traits&lt;Graph&gt;::vertex_descriptor sink,
+   const bgl_named_params&lt;P, T, R&gt;&amp; params = <I>all defaults</I>)
+
+<I>// non-named parameter version</I>
+template &lt;class Graph, class CapacityEdgeMap, class ResidualCapacityEdgeMap, class ReverseEdgeMap,
+          class PredecessorMap, class ColorMap, class DistanceMap, class IndexMap&gt;
+typename property_traits&lt;CapacityEdgeMap&gt;::value_type
+boykov_kolmogorov_max_flow(Graph&amp; g,
+       CapacityEdgeMap cap,
+       ResidualCapacityEdgeMap res_cap,
+       ReverseEdgeMap rev_map,
+       PredecessorMap pre_map,
+       ColorMap color,
+       DistanceMap dist,
+       IndexMap idx,
+       typename graph_traits &lt;Graph&gt;::vertex_descriptor src,
+       typename graph_traits &lt;Graph &gt;::vertex_descriptor sink)</PRE><P>
+<FONT SIZE=3>Additional overloaded versions for non-named parameters
+are provided (without DistanceMap/ColorMap/DistanceMap; for those
+iterator_property_maps with the provided index map are used)</FONT></P>
+<P>The <TT>boykov_kolmogorov_max_flow()</TT> function calculates the maximum
+flow of a network. See Section <A HREF="graph_theory_review.html#sec:network-flow-algorithms">Network
+Flow Algorithms</A> for a description of maximum flow. The calculated
+maximum flow will be the return value of the function. The function
+also calculates the flow values <I>f(u,v)</I> for all <I>(u,v)</I> in
+<I>E</I>, which are returned in the form of the residual capacity
+<I>r(u,v) = c(u,v) - f(u,v)</I>.
+</P>
+<P><B>Requirements:</B><BR>The directed graph <I>G=(V,E)</I> that
+represents the network must include a reverse edge for every edge in
+<I>E</I>. That is, the input graph should be <I>G<SUB>in</SUB> =
+(V,{E U E<SUP>T</SUP>})</I>. The <TT>ReverseEdgeMap</TT> argument <TT>rev</TT>
+must map each edge in the original graph to its reverse edge, that is
+<I>(u,v) -&gt; (v,u)</I> for all <I>(u,v)</I> in <I>E</I>.
+</P>
+
+<P>Remarks: While the push-relabel method states that each edge in <I>E<SUP>T</SUP></I>
+has to have capacity of 0, the reverse edges for this algorithm ARE
+allowed to carry capacities. If there are already reverse edges in
+the input Graph <I><FONT FACE="Courier New, monospace">G</FONT></I>,
+those can be used. This can halve the amount of edges and will
+noticeably increase the performance.</P>
+
+<P>
+<B>Algorithm description:</B><BR>The Boykov-Kolmogorov max-flow (or often
+BK max-flow) algorithm is a variety of the augmenting-path algorithm. Standard
+augmenting path algorithms find shortest paths from source to sink vertex and
+augment them by subtracting the bottleneck capacity found on that path from the
+residual capacities of each edge and adding it to the total flow. Additionally
+the minimum capacity is added to the residual capacity of the reverse edges. If
+no more paths in the residual-edge tree are found, the algorithm terminates.
+Instead of finding a new shortest path from source to sink in the graph in each
+iteration, the Boykov-Kolmogorov algorithm keeps the already found paths as
+follows:</P>
+
+<P>The algorithm builds up two search trees, a source-tree and a
+sink-tree. Each vertex has a label (stored in <I>ColorMap</I>) to
+which tree it belongs and a status-flag if this vertex is active or
+passive. In the beginning of the algorithm only the source and the
+sink are colored (source==black, sink==white) and have active status.
+All other vertices are colored gray. The algorithm consists of three
+phases:</P>
+<P><I>grow-phase</I>: In this phase active vertices are allowed to
+acquire neighbor vertices that are connected through an edge that has
+a capacity-value greater than zero. Acquiring means that those vertices
+become active and belong now to the search tree of the current
+active vertex. If there are no more valid connections to neighbor
+vertices, the current vertex becomes passive and the grow phase
+continues with the next active vertex. The grow phase terminates if
+there are no more active vertices left or a vertex discovers a vertex
+from the other search tree through an unsaturated edge. In this case
+a path from source to sink is found.</P>
+<P><I>augment-phase</I>: This phase augments the path that was found
+in the grow phase. First it finds the bottleneck capacity of the
+found path, and then it updates the residual-capacity of the edges
+from this path by subtracting the bottleneck capacity from the
+residual capacity. Furthermore the residual capacity of the reverse
+edges are updated by adding the bottleneck capacity. This phase can
+destroy the built up search trees, as it creates at least one
+saturated edge. That means, that the search trees collapse to
+forests, because a condition for the search trees is, that each
+vertex in them has a valid (=non-saturated) connection to a terminal.</P>
+<P><I>adoption-phase</I>: Here the search trees are reconstructed. A
+simple solution would be to mark all vertices coming after the first
+orphan in the found path free vertices (gray). A more sophisticated
+solution is to give those orphans new parents: The neighbor vertices
+are checked if they have a valid connection to the same terminal like
+this vertex had (a path with unsaturated edges). If there is one,
+this vertex becomes the new parent of the current orphan and this
+forest is re-included into the search tree. If no new valid parent is
+found, this vertex becomes a free vertex (marked gray), and it's
+children become orphans. The adoption phase terminates if there are
+no more orphans.</P>
+<P><IMG SRC="figs/bk_max_flow.gif" NAME="Grafik2" ALIGN=LEFT WIDTH=827 HEIGHT=311 BORDER=0><BR CLEAR=LEFT><B>Details:</B></P>
+<UL>
+	<LI><P>Marking heuristics: A timestamp is stored for each vertex
+	which shows in which iteration of the algorithm the distance to the
+	corresponding terminal was calculated.
+	</P>
+	<UL>
+		<LI><P>This distance is used and gets calculated in the
+		adoption-phase. In order to find a valid new parent for an orphan,
+		the possible parent is checked for a connection to the terminal to
+		which tree it belongs. If there is such a connection, the path is
+		tagged with the current time-stamp, and the distance value. If
+		another orphan has to find a parent and it comes across a vertex
+		with a current timestamp, this information is used.</P>
+		<LI><P>The distance is also used in the grow-phase. If a vertex
+		comes across another vertex of the same tree while searching for
+		new vertices, the other's distance is compared to its distance. If
+		it is smaller, that other vertex becomes the new parent of the
+		current. This can decrease the length of the search paths, and so
+		amount of adoptions.</P>
+	</UL>
+	<LI><P>Ordering of orphans: As described above, the augment-phase
+	and the adoption phase can create orphans. The orphans the
+	augment-phase generates, are ordered according to their distance to
+	the terminals (smallest first). This combined with the
+	distance/timestamp heuristics results in the possibility for not
+	having to recheck terminal-connections too often. New orphans which
+	are generated in adoption phase are processed before orphans from
+	the main queue for the same reason.</P>
+</UL>
+<P><BR><B>Implementation notes:</B></P>
+<P>The algorithm is mainly implemented as described by Boykov and Kolmogorov in
+[<a href="bibliography.html#boykov-kolmogorov04">69</a>]. An extended version
+can be found in the PhD Thesis of Kolmogorov [<A HREF="bibliography.html#kolmogorov03">68</a>].
+The following changes are made to improve performance:</P>
+<UL>
+	<LI>initialization: the algorithm first augments all paths from
+	source-&gt;sink and all paths from source-&gt;VERTEX-&gt;sink. This
+	improves especially graph-cuts used in image vision where nearly
+	each vertex has a source and sink connect. During this step, all
+	vertices that have an unsaturated connection from source are added
+	to the active vertex list and so the source is not.</LI>
+	<LI>active vertices: Boykov-Kolmogorov uses two lists for active nodes
+	and states that new active vertices are added to the rear of the
+	second. Fetching an active vertex is done from the beginning of the
+	first list. If the first list is empty, it is exchanged by the
+	second. This implementation uses just one list.</LI>
+	<LI>grow-phase: In the grow phase the first vertex in the
+	active-list is taken and all outgoing edges are checked if they are
+	unsaturated. This decreases performance for graphs with high-edge
+	density. This implementation stores the last accessed edge and
+	continues with it, if the first vertex in the active-list is the
+	same one as during the last grow-phase.</LI>
+</UL>
+<H3>Where Defined</H3>
+<P><TT><A HREF="../../../boost/graph/boykov_kolmogorov_max_flow.hpp">boost/graph/boykov_kolmogorov_max_flow.hpp</A></TT>
+</P>
+<H3>Parameters</H3>
+<P>IN: <TT>Graph&amp; g</TT>
+</P>
+<BLOCKQUOTE>A directed graph. The graph's type must be a model of
+<A HREF="VertexListGraph.html">Vertex List Graph</A>, <A HREF="EdgeListGraph.html">Edge
+List Graph</A> and <A HREF="IncidenceGraph.html">Incidence Graph</A>.
+For each edge <I>(u,v)</I> in the graph, the reverse edge <I>(v,u)</I>
+must also be in the graph.  Performance of the algorithm will be slightly
+improved if the graph type also models <a href="AdjacencyMatrix.html">Adjacency
+Matrix</a>.
+</BLOCKQUOTE>
+<P>IN: <TT>vertex_descriptor src</TT>
+</P>
+<BLOCKQUOTE>The source vertex for the flow network graph.
+</BLOCKQUOTE>
+<P>IN: <TT>vertex_descriptor sink</TT>
+</P>
+<BLOCKQUOTE>The sink vertex for the flow network graph.
+</BLOCKQUOTE>
+<H3>Named Parameters</H3>
+<P>IN: <TT>edge_capacity(EdgeCapacityMap cap)</TT>
+</P>
+<BLOCKQUOTE>The edge capacity property map. The type must be a model
+of a constant <A HREF="../../property_map/doc/LvaluePropertyMap.html">Lvalue
+Property Map</A>. The key type of the map must be the graph's edge
+descriptor type.<BR><B>Default:</B> <TT>get(edge_capacity, g)</TT>
+</BLOCKQUOTE>
+<P>OUT: <TT>edge_residual_capacity(ResidualCapacityEdgeMap res)</TT>
+</P>
+<BLOCKQUOTE>The edge residual capacity property map. The type must be
+a model of a mutable <A HREF="../../property_map/doc/LvaluePropertyMap.html">Lvalue
+Property Map</A>. The key type of the map must be the graph's edge
+descriptor type.<BR><B>Default:</B> <TT>get(edge_residual_capacity,
+g)</TT>
+</BLOCKQUOTE>
+<P>IN: <TT>edge_reverse(ReverseEdgeMap rev)</TT>
+</P>
+<BLOCKQUOTE>An edge property map that maps every edge <I>(u,v)</I> in
+the graph to the reverse edge <I>(v,u)</I>. The map must be a model
+of constant <A HREF="../../property_map/doc/LvaluePropertyMap.html">Lvalue
+Property Map</A>. The key type of the map must be the graph's edge
+descriptor type.<BR><B>Default:</B> <TT>get(edge_reverse, g)</TT>
+</BLOCKQUOTE>
+<P>UTIL: <TT>vertex_predecessor(PredecessorMap pre_map)</TT>
+</P>
+<BLOCKQUOTE>A vertex property map that stores the edge to the vertex'
+predecessor. The map must be a model of mutable <A HREF="../../property_map/doc/LvaluePropertyMap.html">Lvalue
+Property Map</A>. The key type of the map must be the graph's vertex
+descriptor type.<BR><B>Default:</B> <TT>get(vertex_predecessor, g)</TT>
+</BLOCKQUOTE>
+<P>OUT/UTIL: <TT>vertex_color(ColorMap color)</TT>
+</P>
+<BLOCKQUOTE>A vertex property map that stores a color for edge
+vertex. If the color of a vertex after running the algorithm is black
+the vertex belongs to the source tree else it belongs to the
+sink-tree (used for minimum cuts). The map must be a model of mutable
+<A HREF="../../property_map/doc/LvaluePropertyMap.html">Lvalue Property
+Map</A>. The key type of the map must be the graph's vertex
+descriptor type.<BR><B>Default:</B> <TT>get(vertex_color, g)</TT>
+</BLOCKQUOTE>
+<P>UTIL: <TT>vertex_distance(DistanceMap dist)</TT>
+</P>
+<BLOCKQUOTE>A vertex property map that stores the distance to the
+corresponding terminal. It's a utility-map for speeding up the
+algorithm. The map must be a model of mutable <A HREF="../../property_map/doc/LvaluePropertyMap.html">Lvalue
+Property Map</A>. The key type of the map must be the graph's vertex
+descriptor type.<BR><B>Default:</B> <TT>get(vertex_distance, g)</TT>
+</BLOCKQUOTE>
+<P>IN: <TT>vertex_index(VertexIndexMap index_map)</TT>
+</P>
+<BLOCKQUOTE>Maps each vertex of the graph to a unique integer in the
+range <TT>[0, num_vertices(g))</TT>. The map must be a model of
+constant <A HREF="../../property_map/doc/LvaluePropertyMap.html">LvaluePropertyMap</A>.
+The key type of the map must be the graph's vertex descriptor
+type.<BR><B>Default:</B> <TT>get(vertex_index, g)</TT>
+</BLOCKQUOTE>
+<H3>Example</H3>
+<P>This reads an example maximum flow problem (a graph with edge
+capacities) from a file in the DIMACS format (<TT><A HREF="../example/max_flow.dat">example/max_flow.dat</A></TT>).
+The source for this example can be found in
+<TT><A HREF="../example/boykov_kolmogorov-eg.cpp">example/boykov_kolmogorov-eg.cpp</A></TT>.
+</P>
+<PRE>#include &lt;boost/config.hpp&gt;
+#include &lt;iostream&gt;
+#include &lt;string&gt;
+#include &lt;boost/graph/adjacency_list.hpp&gt;
+#include &lt;boost/graph/boykov_kolmogorov_max_flow.hpp&gt;
+#include &lt;boost/graph/read_dimacs.hpp&gt;
+#include &lt;boost/graph/graph_utility.hpp&gt;
+
+int
+main()
+{
+  using namespace boost;
+
+  typedef adjacency_list_traits &lt; vecS, vecS, directedS &gt; Traits;
+  typedef adjacency_list &lt; vecS, vecS, directedS,
+    property &lt; vertex_name_t, std::string,
+    property &lt; vertex_index_t, long,
+    property &lt; vertex_color_t, boost::default_color_type,
+    property &lt; vertex_distance_t, long,
+    property &lt; vertex_predecessor_t, Traits::edge_descriptor &gt; &gt; &gt; &gt; &gt;,
+
+    property &lt; edge_capacity_t, long,
+    property &lt; edge_residual_capacity_t, long,
+    property &lt; edge_reverse_t, Traits::edge_descriptor &gt; &gt; &gt; &gt; Graph;
+
+  Graph g;
+  property_map &lt; Graph, edge_capacity_t &gt;::type
+      capacity = get(edge_capacity, g);
+  property_map &lt; Graph, edge_residual_capacity_t &gt;::type
+      residual_capacity = get(edge_residual_capacity, g);
+  property_map &lt; Graph, edge_reverse_t &gt;::type rev = get(edge_reverse, g);
+  Traits::vertex_descriptor s, t;
+  read_dimacs_max_flow(g, capacity, rev, s, t);
+
+  std::vector&lt;default_color_type&gt; color(num_vertices(g));
+  std::vector&lt;long&gt; distance(num_vertices(g));
+  long flow = boykov_kolmogorov_max_flow(g ,s, t);
+
+  std::cout &lt;&lt; "c  The total flow:" &lt;&lt; std::endl;
+  std::cout &lt;&lt; "s " &lt;&lt; flow &lt;&lt; std::endl &lt;&lt; std::endl;
+
+  std::cout &lt;&lt; "c flow values:" &lt;&lt; std::endl;
+  graph_traits &lt; Graph &gt;::vertex_iterator u_iter, u_end;
+  graph_traits &lt; Graph &gt;::out_edge_iterator ei, e_end;
+  for (boost::tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
+    for (boost::tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
+      if (capacity[*ei] &gt; 0)
+        std::cout &lt;&lt; "f " &lt;&lt; *u_iter &lt;&lt; " " &lt;&lt; target(*ei, g) &lt;&lt; " "
+          &lt;&lt; (capacity[*ei] - residual_capacity[*ei]) &lt;&lt; std::endl;
+
+  return EXIT_SUCCESS;
+}</PRE><P>
+The output is:
+</P>
+<PRE>c  The total flow:
+s 13
+
+c flow values:
+f 0 6 3
+f 0 1 0
+f 0 2 10
+f 1 5 1
+f 1 0 0
+f 1 3 0
+f 2 4 4
+f 2 3 6
+f 2 0 0
+f 3 7 5
+f 3 2 0
+f 3 1 1
+f 4 5 4
+f 4 6 0
+f 5 4 0
+f 5 7 5
+f 6 7 3
+f 6 4 0
+f 7 6 0
+f 7 5 0</PRE><H3>
+See Also</H3>
+<P STYLE="margin-bottom: 0cm">
+<TT><A HREF="edmonds_karp_max_flow.html">edmonds_karp_max_flow()</A></TT>,
+<TT><A HREF="push_relabel_max_flow.html">push_relabel_max_flow()</A></TT>.
+</P>
+<HR>
+<TABLE CELLPADDING=2 CELLSPACING=2>
+	<TR VALIGN=TOP>
+		<TD>
+			<P>Copyright &copy; 2006</P>
+		</TD>
+		<TD>
+			<P>Stephan Diederich, University
+			Mannheim(<A HREF="mailto:diederich@ti.uni-manheim.de">diederich@ti.uni-manheim.de</A>)</P>
+		</TD>
+	</TR>
+</TABLE>
+<P><BR><BR>
+</P>
+</BODY>
+</HTML>

doc/breadth_first_search.html

@@ -0,0 +1,338 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek 2000, 2001
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Breadth-First Search</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><A NAME="sec:bfs">
+<img src="figs/python.gif" alt="(Python)"/>
+<TT>breadth_first_search</TT>
+</H1>
+
+<P>
+<PRE>
+<i>// named parameter version</i>
+template &lt;class Graph, class P, class T, class R&gt;
+void breadth_first_search(Graph& G, 
+  typename graph_traits&lt;Graph&gt;::vertex_descriptor s, 
+  const bgl_named_params&lt;P, T, R&gt;&amp; params);
+
+<i>// non-named parameter version</i>
+template &lt;class Graph, class Buffer, class BFSVisitor, 
+	  class ColorMap&gt;
+void breadth_first_search(const Graph&amp; g, 
+   typename graph_traits&lt;Graph&gt;::vertex_descriptor s, 
+   Buffer&amp; Q, BFSVisitor vis, ColorMap color);
+</PRE>
+
+
+<p>
+The <tt>breadth_first_search()</tt> function performs a breadth-first
+traversal [<a href="./bibliography.html#moore59">49</a>] of a directed
+or undirected graph.  A breadth-first traversal visits vertices that
+are closer to the source before visiting vertices that are further
+away. In this context ``distance'' is defined as the number of edges
+in the shortest path from the source vertex. The
+<tt>breadth_first_search()</tt> function can be used to compute the
+shortest path from the source to all reachable vertices and the
+resulting shortest-path distances. For more definitions related to BFS
+see section <a href="./graph_theory_review.html#sec:bfs-algorithm">
+Breadth-First Search</a>.
+</p>
+
+<p>
+BFS uses two data structures to to implement the traversal: a color
+marker for each vertex and a queue. White vertices are undiscovered
+while gray vertices are discovered but have undiscovered adjacent
+vertices. Black vertices are discovered and are adjacent to only other
+black or gray vertices.  The algorithm proceeds by removing a vertex
+</i>u</i> from the queue and examining each out-edge <i>(u,v)</i>. If an
+adjacent vertex <i>v</i> is not already discovered, it is colored gray and
+placed in the queue. After all of the out-edges are examined, vertex
+<i>u</i> is colored black and the process is repeated.  Pseudo-code for the
+BFS algorithm is a listed below.
+</p>
+
+<table>
+<tr>
+<td valign="top">
+<pre>
+BFS(<i>G</i>, <i>s</i>)
+  <b>for</b> each vertex <i>u in V[G]</i>
+    <i>color[u] :=</i> WHITE 
+    <i>d[u] := infinity</i> 
+    <i>p[u] := u</i> 
+  <b>end for</b>
+  <i>color[s] :=</i> GRAY 
+  <i>d[s] := 0</i> 
+  ENQUEUE(<i>Q</i>, <i>s</i>)
+  <b>while</b> (<i>Q != &Oslash;</i>) 
+    <i>u :=</i> DEQUEUE(Q)
+    <b>for</b> each vertex <i>v in Adj[u]</i>
+      <b>if</b> (<i>color[v] =</i> WHITE)
+        <i>color[v] :=</i> GRAY 
+        <i>d[v] := d[u] + 1</i>  
+        <i>p[v] := u</i>  
+        ENQUEUE(<i>Q</i>, <i>v</i>)
+      <b>else</b>
+        <b>if</b> (<i>color[v] =</i> GRAY) 
+          ...
+        <b>else</b> 
+          ...
+    <b>end for</b>
+    <i>color[u] :=</i> BLACK
+  <b>end while</b>
+  return (<i>d</i>, <i>p</i>)
+</pre>
+</td>
+<td valign="top">
+<pre>
+
+initialize vertex <i>u</i> 
+
+
+
+
+
+
+discover vertex <i>s</i> 
+
+examine vertex <i>u</i> 
+examine edge <i>(u,v)</i>
+<i>(u,v)</i> is a tree edge 
+
+
+
+discover vertex <i>v</i> 
+<i>(u,v)</i> is a non-tree edge
+
+<i>(u,v)</i> has a gray target 
+
+<i>(u,v)</i> has a black target 
+
+finish vertex <i>u</i> 
+</pre>
+</tr>
+</table>
+
+The <tt>breadth_first_search()</tt> function can be extended with
+user-defined actions that will be called a certain event points. The
+actions must be provided in the form of a visitor object, that is, an
+object who's type meets the requirements for a <a
+href="./BFSVisitor.html">BFS Visitor</a>. In the above pseudo-code,
+the event points are the labels on the right. Also a description of
+each event point is given below. By default, the
+<tt>breadth_first_search()</tt> function does not carry out any
+actions, not even recording distances or predecessors. However these
+can be easily added using the <a
+href="./distance_recorder.html"><tt>distance_recorder</tt></a> and <a
+href="./predecessor_recorder.html"><tt>predecessor_recorder</tt></a>
+event visitors.
+
+
+<H3>Where Defined</H3>
+
+<P>
+<a href="../../../boost/graph/breadth_first_search.hpp"><TT>boost/graph/breadth_first_search.hpp</TT></a>
+
+<P>
+
+<h3>Parameters</h3>
+
+IN: <tt>Graph&amp; g</tt>
+<blockquote>
+  A directed or undirected graph. The graph type must
+  be a model of <a href="./VertexListGraph.html">Vertex List Graph</a>
+  and <a href="./IncidenceGraph.html">Incidence Graph</a>.<br>
+
+  <b>Python</b>: The parameter is named <tt>graph</tt>.
+</blockquote>
+
+IN: <tt>vertex_descriptor s</tt>
+<blockquote>
+  The source vertex where the search is started.<br>
+
+  <b>Python</b>: The parameter is named <tt>root_vertex</tt>.
+</blockquote>
+
+
+<h3>Named Parameters</h3>
+
+IN: <tt>visitor(BFSVisitor vis)</tt>
+<blockquote>
+  A visitor object that is invoked inside the algorithm at the
+  event-points specified by the <a href="BFSVisitor.html">BFS
+  Visitor</a> concept. The visitor object is passed by value <a
+  href="#1">[1]</a>.<br> <b>Default:</b>
+  <tt>bfs_visitor&lt;null_visitor&gt;</tt> <br>
+
+  <b>Python</b>: The parameter should be an object that derives from
+  the <a href="BFSVisitor.html#python"><tt>BFSVisitor</tt></a> type of the graph.
+
+</blockquote>
+
+UTIL/OUT: <tt>color_map(ColorMap color)</tt>
+<blockquote>
+  This is used by the algorithm to keep track of its progress through
+  the graph. The user need not initialize the color map before calling
+  <tt>breadth_first_search()</tt> since the algorithm initializes the
+  color of every vertex to white at the start of the algorihtm. If you
+  need to perform multiple breadth-first searches on a graph (for
+  example, if there are some disconnected components) then use the <a
+  href="./breadth_first_visit.html"><tt>breadth_first_visit()</tt></a>
+  function and do your own color initialization.
+
+  <p>The type <tt>ColorMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a> and its key type must be the graph's vertex
+  descriptor type and the value type of the color map must model
+  <a href="./ColorValue.html">ColorValue</a>.<br>
+  <b>Default:</b> an <a
+  href="../../property_map/doc/iterator_property_map.html">
+  </tt>iterator_property_map</tt></a> created from a
+  <tt>std::vector</tt> of <tt>default_color_type</tt> of size
+  <tt>num_vertices(g)</tt> and using the <tt>i_map</tt> for the index
+  map.<br>
+
+  <b>Python</b>: The color map must be a <tt>vertex_color_map</tt> for
+  the graph.
+</blockquote>
+
+IN: <tt>vertex_index_map(VertexIndexMap i_map)</tt>
+<blockquote>
+  This maps each vertex to an integer in the range <tt>[0,
+  num_vertices(g))</tt>. This parameter is only necessary when the
+  default color property map is used. The type <tt>VertexIndexMap</tt>
+  must be a model of <a
+  href="../../property_map/doc/ReadablePropertyMap.html">Readable Property
+  Map</a>. The value type of the map must be an integer type. The
+  vertex descriptor type of the graph needs to be usable as the key
+  type of the map.<br>
+
+  <b>Default:</b> <tt>get(vertex_index, g)</tt>.
+    Note: if you use this default, make sure your graph has
+    an internal <tt>vertex_index</tt> property. For example,
+    <tt>adjacency_list</tt> with <tt>VertexList=listS</tt> does
+    not have an internal <tt>vertex_index</tt> property.<br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+UTIL: <tt>buffer(Buffer&amp; Q)</tt>
+<blockquote>
+  The queue used to determine the order in which vertices will be
+  discovered.  If a FIFO queue is used, then the traversal will
+  be according to the usual BFS ordering. Other types of queues
+  can be used, but the traversal order will be different.
+  For example Dijkstra's algorithm can be implemented
+  using a priority queue. The type <tt>Buffer</tt> must be a model of
+  <a href="./Buffer.html">Buffer</a>.<br> The <tt>value_type</tt>
+  of the buffer must be the <tt>vertex_descriptor</tt> type for the graph.<br>
+  <b>Default:</b> <tt>boost::queue</tt><br>
+
+  <b>Python</b>: The buffer must derive from the <a
+  href="./Buffer.html">Buffer</a> type for the graph.
+
+</blockquote>  
+
+
+<H3><A NAME="SECTION001330300000000000000">
+Complexity</A>
+</H3>
+
+<P>
+The time complexity is <i>O(E + V)</i>. 
+
+<P>
+
+<h3>Visitor Event Points</h3>
+
+<ul>
+<li><b><tt>vis.initialize_vertex(v, g)</tt></b> is invoked on every vertex
+  before the start of the search. 
+
+<li><b><tt>vis.examine_vertex(u, g)</tt></b>r is invoked in each
+  vertex as it is removed from the queue.
+
+<li><b><tt>vis.examine_edge(e, g)</tt></b> is invoked on every out-edge
+  of each vertex immediately after the vertex is removed from the queue. 
+
+<li><b><tt>vis.tree_edge(e, g)</tt></b> is invoked (in addition to
+  <tt>examine_edge()</tt>) if the edge is a tree edge. The
+  target vertex of edge <tt>e</tt> is discovered at this time.
+
+<li><b><tt>vis.discover_vertex(u, g)</tt></b> is invoked the first time the
+  algorithm encounters vertex <i>u</i>. All vertices closer to the
+  source vertex have been discovered, and vertices further from the
+  source have not yet been discovered. 
+
+<li><b><tt>vis.non_tree_edge(e, g)</tt></b> is invoked (in addition to
+  <tt>examine_edge()</tt>) if the edge is not a tree edge. 
+
+<li><b><tt>vis.gray_target(e, g)</tt></b> is invoked (in addition to
+  <tt>non_tree_edge()</tt>) if the target vertex is colored gray at the
+  time of examination. The color gray indicates that
+  the vertex is currently in the queue. 
+
+<li><b><tt>vis.black_target(e, g)</tt></b> is invoked (in addition to
+  <tt>non_tree_edge()</tt>) if the target vertex is colored black at the
+  time of examination. The color black indicates that the
+  vertex is no longer in the queue. 
+
+<li><b><tt>vis.finish_vertex(u, g)</tt></b> is invoked after all of the out
+  edges of <i>u</i> have been examined and all of the adjacent vertices
+  have been discovered.
+
+</ul>
+
+<H3><A NAME="SECTION001330400000000000000">
+Example</A>
+</H3>
+
+<P>
+The example in <a
+href="../example/bfs-example.cpp"><TT>example/bfs-example.cpp</TT></a>
+demonstrates using the BGL Breadth-first search algorithm on the graph
+from <A HREF="./graph_theory_review.html#fig:bfs-example">Figure
+6</A>. The file
+<a href="../example/bfs-example2.cpp"><TT>example/bfs-example2.cpp</TT></a>
+contains the same example, except that the <tt>adacency_list</tt>
+class used has <tt>VertexList</tt> and <tt>EdgeList</tt> set
+to <tt>listS</tt>.
+</P>
+
+<h3>See Also</h3>
+
+<a href="./bfs_visitor.html"><tt>bfs_visitor</tt></a> and
+<a href="./depth_first_search.html"><tt>depth_first_search()</tt></a>
+
+<h3>Notes</h3>
+
+<p><a name="1">[1]</a> 
+  Since the visitor parameter is passed by value, if your visitor
+  contains state then any changes to the state during the algorithm
+  will be made to a copy of the visitor object, not the visitor object
+  passed in. Therefore you may want the visitor to hold this state by
+  pointer or reference.
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 

doc/breadth_first_visit.html

@@ -0,0 +1,186 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek 2000, 2001
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Breadth-First Visit</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><A NAME="sec:bfv"><img src="figs/python.gif" alt="(Python)"/>
+<TT>breadth_first_visit</TT>
+</H1>
+
+<P>
+<PRE>
+  template &lt;class <a href="./IncidenceGraph.html">IncidenceGraph</a>, class P, class T, class R&gt;
+  void breadth_first_visit(IncidenceGraph& G, 
+    typename graph_traits&lt;IncidenceGraph&gt;::vertex_descriptor s, 
+    const bgl_named_params&lt;P, T, R&gt;&amp; params);
+
+  template &lt;class <a href="./IncidenceGraph.html">IncidenceGraph</a>, class <a href="./Buffer.html">Buffer</a>, class <a href="./BFSVisitor.html">BFSVisitor</a>, class ColorMap&gt;
+  void breadth_first_visit
+    (const IncidenceGraph&amp; g, 
+     typename graph_traits&lt;IncidenceGraph&gt;::vertex_descriptor s, 
+     Buffer&amp; Q, BFSVisitor vis, ColorMap color)
+</PRE>
+
+This function is basically the same as <tt>breadth_first_search()</tt>
+except that the color markers are not initialized in the
+algorithm. The user is responsible for making sure the color for every
+vertex is white before calling the algorithm.  With this difference,
+the graph type is only required to be an <a
+href="./IncidenceGraph.html">Incidence Graph</a> instead of a <a
+href="./VertexListGraph.html">Vertex List Graph</a>.  Also, this
+difference allows for more flexibility in the color property map. For
+example, one could use a map that only implements a partial function
+on the vertices, which could be more space efficient when the search
+only reaches a small portion of the graph.
+
+<H3>Where Defined</H3>
+
+<P>
+<a href="../../../boost/graph/breadth_first_search.hpp"><TT>boost/graph/breadth_first_search.hpp</TT></a>
+
+
+<h3>Parameters</h3>
+
+IN: <tt>IncidenceGraph&amp; g</tt>
+<blockquote>
+  A directed or undirected graph. The graph type must
+  be a model of <a href="./IncidenceGraph.html">Incidence Graph</a>.<br>
+
+  <b>Python</b>: The parameter is named <tt>graph</tt>.
+</blockquote>
+
+IN: <tt>vertex_descriptor s</tt>
+<blockquote>
+  The source vertex where the search is started.<br>
+
+  <b>Python</b>: The parameter is named <tt>root_vertex</tt>.
+</blockquote>
+
+
+<h3>Named Parameters</h3>
+
+IN: <tt>visitor(BFSVisitor vis)</tt>
+<blockquote>
+  A visitor object that is invoked inside the algorithm at the
+  event-points specified by the <a href="BFSVisitor.html">BFS
+  Visitor</a> concept. The visitor object is passed by value <a
+  href="#1">[1]</a>.<br> <b>Default:</b>
+  <tt>bfs_visitor&lt;null_visitor&gt;</tt><br>
+
+  <b>Python</b>: The parameter should be an object that derives from
+  the <a href="BFSVisitor.html#python"><tt>BFSVisitor</tt></a> type of the graph.
+</blockquote>
+
+UTIL/OUT: <tt>color_map(ColorMap color)</tt>
+<blockquote>
+  This is used by the algorithm to keep track of its progress through
+  the graph. The type <tt>ColorMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a> and its key type must be the graph's vertex
+  descriptor type and the value type of the color map must model
+  <a href="./ColorValue.html">ColorValue</a>.<br>
+  <b>Default:</b> <tt>get(vertex_color, g)</tt><br>
+
+  <b>Python</b>: The color map must be a <tt>vertex_color_map</tt> for
+  the graph.
+</blockquote>
+
+UTIL: <tt>buffer(Buffer&amp; Q)</tt>
+<blockquote>
+  The queue used to determine the order in which vertices will be
+  discovered.  If a FIFO queue is used, then the traversal will
+  be according to the usual BFS ordering. Other types of queues
+  can be used, but the traversal order will be different.
+  For example Dijkstra's algorithm can be implemented
+  using a priority queue. The type <tt>Buffer</tt> must be a model of
+  <a href="./Buffer.html">Buffer</a>.<br>
+  <b>Default:</b> <tt>boost::queue</tt><br>
+
+  <b>Python</b>: The buffer must derive from the <a
+  href="./Buffer.html">Buffer</a> type for the graph.
+</blockquote>  
+
+
+<H3><A NAME="SECTION001330300000000000000">
+Complexity</A>
+</H3>
+
+<P>
+The time complexity is <i>O(E)</i>. 
+
+<P>
+
+<h3>Visitor Event Points</h3>
+
+<ul>
+<li><b><tt>vis.examine_vertex(u, g)</tt></b>r is invoked in each
+  vertex as it is removed from the queue.
+
+<li><b><tt>vis.examine_edge(e, g)</tt></b> is invoked on every out-edge
+  of each vertex immediately after the vertex is removed from the queue. 
+
+<li><b><tt>vis.tree_edge(e, g)</tt></b> is invoked (in addition to
+  <tt>examine_edge()</tt>) if the edge is a tree edge. The
+  target vertex of edge <tt>e</tt> is discovered at this time.
+
+<li><b><tt>vis.discover_vertex(u, g)</tt></b> is invoked the first time the
+  algorithm encounters vertex <i>u</i>. All vertices closer to the
+  source vertex have been discovered, and vertices further from the
+  source have not yet been discovered. 
+
+<li><b><tt>vis.non_tree_edge(e, g)</tt></b> is invoked (in addition to
+  <tt>examine_edge()</tt>) if the edge is not a tree edge. 
+
+<li><b><tt>vis.gray_target(e, g)</tt></b> is invoked (in addition to
+  <tt>non_tree_edge()</tt>) if the target vertex is colored gray at the
+  time of examination. The color gray indicates that
+  the vertex is currently in the queue. 
+
+<li><b><tt>vis.black_target(e, g)</tt></b> is invoked (in addition to
+  <tt>non_tree_edge()</tt>) if the target vertex is colored black at the
+  time of examination. The color black indicates that the
+  vertex is no longer in the queue. 
+
+<li><b><tt>vis.finish_vertex(u, g)</tt></b> is invoked after all of the out
+  edges of <i>u</i> have been examined and all of the adjacent vertices
+  have been discovered.
+
+</ul>
+
+<h3>See Also</h3>
+
+<a href="./breadth_first_search.html"><tt>breadth_first_search()</tt></a>,
+<a href="./bfs_visitor.html"><tt>bfs_visitor</tt></a>, and
+<a href="./depth_first_search.html"><tt>depth_first_search()</tt></a>
+
+<h3>Notes</h3>
+
+<p><a name="1">[1]</a> 
+  Since the visitor parameter is passed by value, if your visitor
+  contains state then any changes to the state during the algorithm
+  will be made to a copy of the visitor object, not the visitor object
+  passed in. Therefore you may want the visitor to hold this state by
+  pointer or reference.
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 

doc/bundles.html

@@ -0,0 +1,228 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<!--
+    Copyright Doug Gregor 2004. 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)
+
+   For more information, see http://www.boost.org
+-->
+<head>
+<title>Bundled Properties</title>
+</head>
+
+<body BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b"
+  ALINK="#ff0000">
+<IMG SRC="../../../boost.png"
+ALT="C++ Boost" width="277" height="86"/>
+<h1>Bundled Properties</h1>
+
+<p>Class templates <code><a
+href="adjacency_list.html">adjacency_list</a></code> and
+<code><a href="adjacency_matrix.html">adjacency_matrix</a></code> support
+the introduction of named properties via <a
+href="using_adjacency_list.html#sec:adjacency-list-properties">internal
+properties</a>. However, this method is cumbersome in many uses,
+where it would be more intuitive to just specify a structure or
+class that contains internal properties for edges or
+vertices. Bundled properties allow one to use
+<code>adjacency_list</code> and <code>adjacency_matrix</code> in this
+manner, providing a simple
+way to introduce and access any number of internal properties
+for vertices and edges.</p>
+
+<p>One can introduce bundled properties into an
+either graph type by providing a user-defined class
+type for the <code>VertexProperties</code> or
+<code>EdgeProperties</code> template arguments. The user-defined
+class may alternatively be placed at the end of a
+<code>property</code> list, replacing the (implicit)
+<code>boost::no_property</code> argument.</p>
+
+<h2>Example: Route planning</h2>
+<p>Consider the implementation of a simple route planner that
+  should find the shortest directions from one city to another
+  via a set of highways. The vertices of the graph are cities,
+  and we may wish to store several bits of information about the
+  city within each vertex:</p>
+<pre>
+struct City
+{
+  string name;
+  int population;
+  vector&lt;int&gt; zipcodes;
+};
+</pre>
+
+<p>
+The edges in the graph represent highways, which also have several interesting
+attributes:
+</p>
+
+<pre>
+struct Highway
+{
+  string name;
+  double miles;
+  int speed_limit;
+  int lanes;
+  bool divided;
+};
+</pre>
+
+<p>With bundled properties, we can directly use the <code>City</code> and
+<code>Highway</code> structures to define the graph:</p>
+<pre>
+typedef boost::adjacency_list&lt;
+    boost::listS, boost::vecS, boost::bidirectionalS,
+    City, Highway&gt;
+  Map;
+</pre>
+
+<p>Without bundled properties, translating this example directly
+into an instantiation of <code>adjacency_list</code> would
+involve several custom properties and would result in a type
+like this:</p>
+<pre>
+typedef boost::adjacency_list&lt;
+    boost::listS, boost::vecS, boost::bidirectionalS,
+    // Vertex properties
+    boost::property&lt;boost::vertex_name_t, std::string,
+    boost::property&lt;population_t, int,
+    boost::property&lt;zipcodes_t, std::vector&lt;int&gt; &gt; &gt; &gt;,
+    // Edge properties
+    boost::property&lt;boost::edge_name_t, std::string,
+    boost::property&lt;boost::edge_weight_t, double,
+    boost::property&lt;edge_speed_limit_t, int,
+    boost::property&lt;edge_lanes_t, int,
+    boost::property&lt;edge_divided, bool&gt; &gt; &gt; &gt; &gt; &gt;
+  Map;
+</pre>
+
+<p>
+Bundling vertex and edge properties greatly simplifies the declaration of
+graphs.
+</p>
+<p>
+In addition to vertex and edge bundles, we can also bundle properties of the
+graph itself. Suppopse we extend the application to include a portfolio of
+route-planning maps for different countries. In addition to the <code>City</code>
+and <code>Highway</code> bundles above, we can declare a graph bundle,
+<code>Country</Code>.
+</p>
+
+<pre>
+struct Country {
+  string name;
+  bool use_right;   // Drive on the left or right
+  bool use_metric;  // mph or km/h
+};
+</pre>
+
+<p>The graph would now be declared as:</p>
+
+<pre>
+<pre>
+typedef boost::adjacency_list&lt;
+    boost::listS, boost::vecS, boost::bidirectionalS,
+    City, Highway, Country&gt;
+  Map;
+</pre>
+</pre>
+
+<h2>Accessing bundled properties</h2>
+<p>To access a bundled property for a particular edge or vertex,
+  subscript your graph with the descriptor of the edge or vertex
+  whose bundled property you wish to access. For instance:</p>
+<pre>
+Map map; // load the map
+Map::vertex_descriptor v = *vertices(map).first;
+map[v].name = "Troy";
+map[v].population = 49170;
+map[v].zipcodes.push_back(12180);
+Map::edge_descriptor e = *out_edges(v, map).first;
+map[e].name = "I-87";
+map[e].miles = 10.;
+map[e].speed_limit = 65;
+map[e].lanes = 4;
+map[e].divided = true;
+</pre>
+
+<p>
+The graph bundle, since it does not correspond to a vertex or edge descripor
+is accessed using the graph_bundle object as a key.
+</p>
+
+<pre>
+map[graph_bundle].name = "United States";
+map[graph_bundle].use_right = true;
+map[graph_bundle].use_metric = false;
+</pre>
+
+
+<h2>Properties maps from bundled properties</h2>
+<p>Often one needs to create a property map from an internal
+  property for use in a generic algorithm. For instance, using the
+  graph without bundled properties we might invoke <a
+    href="dijkstra_shortest_paths.html">Dijkstra's shortest
+    paths</a> algorithm like this:</p>
+<pre>
+vector&lt;double&gt; distances(num_vertices(map));
+dijkstra_shortest_paths(map, from,
+      weight_map(get(edge_length, map))
+      .distance_map(make_iterator_property_map(distances.begin(),
+                                               get(vertex_index, map))));
+</pre>
+
+<p>With bundled properties, we can just pass a <em>member pointer</em>
+as the property for <code>get</code>. The equivalent example using bundled
+properties is:</p>
+<pre>
+vector&lt;double&gt; distances(num_vertices(map));
+dijkstra_shortest_paths(map, from,
+      weight_map(get(<font color="#ff0000">&amp;Highway::miles</font>, map))
+      .distance_map(make_iterator_property_map(distances.begin(),
+                                               get(vertex_index, map))));
+</pre>
+
+<p>The type of the returned property map is <code>property_map&lt;Map, double Highway::*&gt;::type</code>
+or <code>property_map&lt;Map, double Highway::*&gt;::const_type</code>, depending on whether the graph
+<code>map</code> is non-constant or constant.
+
+<p> You may also access the entire vertex or edge bundle as a property map
+using the <code>vertex_bundle</code> or <code>edge_bundle</code> properties,
+respectively. For instance, the property map returned by <code>get(vertex_bundle, map)</code> is
+an <a href="../../property_map/doc/LvaluePropertyMap.html">Lvalue Property Map</a> providing access to the
+<code>City</code> values stored in each vertex.
+
+<h2>Property maps for a graph bundle</h2>
+There is currently no support for creating property maps from the bundled
+properties of a graph.
+
+<h2>Getting the type of bundled properties</h2>
+
+<p>To get the type of the vertex or edge bundle for a given graph
+type <tt>Graph</tt>, you can use the trait
+classes <tt>vertex_bundle_type</tt>
+and <tt>edge_bundle_type</tt>. The
+type <tt>vertex_bundle_type&lt;Graph&gt;::type</tt> will be the
+type bundled with vertices (or <tt>no_vertex_bundle</tt> if the
+graph supports bundles but no vertex bundle
+exists). Likewise, <tt>edge_bundle_type&lt;Graph&gt;::type</tt>
+will be the type bundled with edges (or <tt>no_edge_bundle</tt> if
+no edge bundle exists).</p>
+
+<h2>Compatibility</h2> <p>Bundled properties will only work
+properly on compilers that support class template partial
+specialization.</p>
+
+<hr>
+Copyright &copy; 2004 <a href="http://www.boost.org/people/doug_gregor.html">Doug Gregor</a>.
+<address><a href="mailto:gregod@cs.rpi.edu"></a></address>
+<!-- Created: Fri May  7 09:59:21 EDT 2004 -->
+<!-- hhmts start -->
+Last modified: Fri May  7 10:56:01 EDT 2004
+<!-- hhmts end -->
+</body>
+</html>

doc/challenge.html

@@ -1,20 +1,16 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  Silicon Graphics makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>Challenge</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -25,30 +21,25 @@
 
 <ul>
 
+<li>Dynamic graph algorithms such as described in <a
+href="http://citeseer.ist.psu.edu/eppstein99dynamic.html">Dynamic Graph
+Algorithms</a> and <a
+href="http://citeseer.ist.psu.edu/alberts98software.html">A Software
+Library of Dynamic Graph Algorithms</a>.
+
 <li>Polish up code/docs for pending items and champion the formal
 review. The pending items are:</li>
   <ul>
    <li><tt>container_traits.hpp</tt> (this should also include
      the work Matt Austern is doing on this topic)</li>
 
-   <li><tt>concept_checks.hpp</tt> </li>
-
-   <li><tt>property.hpp</tt></li>
-
    <li>The queues and heaps: <tt>queue.hpp</tt>,
      <tt>mutable_queue.hpp</tt>, <tt>fibonacci_heap.hpp</tt>.
       Somehow merge implementation with Dietmer's heaps and queues.</li>
 
-   <li><tt>iterator_adaptor.hpp</tt> (need to figure out
-    why this causes problems for VC++)</li>
-
    <li><tt>disjoint_sets</tt> </li>
   </ul>
 
-<li>Port the graph library to Borland C++</li>
-
-<li>Port the graph library to Metrowerks C++</li>
-
 <li>Construct a set of planar graph algorithms.</li>
   <ul>
    <li> Is the graph planar?</li>
@@ -67,15 +58,19 @@ polygons.</li>
     according to a user defined comparison object.</li>
   </ul>
 
-<li>Finish and test Maximum Flow algorithm.</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.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.qhull.org/news/qhull-news.html#users">applications</a>.
+It is currently difficult to use from a C++ program.
 
-<li>Create an <tt>adjacency_matrix</tt> class that models
- the <a href="./AdjacencyMatrix.html">AdjacencyMatrix</a>
- concept.</li>
+</li>
 
-<li>Floyd-Warshall algorithm.</li>
-
-<li>Rewrite the Qhull algorithm using the Boost Graph Library.</li>
 
 <li>Explore the use of Algorithm Objects as an alternative to
   the current approach with visitors.</li>
@@ -94,27 +89,31 @@ polygons.</li>
 <li>Modularize the tests in test/graph.cpp to apply to particular
   concepts. Make sure there are run-time tests for every BGL concept.</li>
 
-<li>Write tests for the BGL algorithms. Currently the examples
-  are used as a sanity check, but they do not constitute a real test. </li>
+<li>Write tests for the BGL algorithms. There are a few, but
+   more are needed. The example provide a sanity check but do not
+   provide full coverage.</li>
 
 <li>Write up the examples from Knuth's <i>Stanford GraphBase</i> using
   the BGL. The file <a
-  href="../examples/miles_span.cpp"><tt>examples/miles_span.cpp</tt></a>
-  is a start.
+  href="../example/miles_span.cpp"><tt>examples/miles_span.cpp</tt></a>
+  is a start.</li>
 
-<li>Create a class to support sub-graph views of a graph, where a
- sub-graph behaves just like a graph, but shares vertex and edge
- properties with the original graph. Perhaps even support sub-graphs
- of sub-graphs, etc.
+<li>Further testing of the <tt>subgraph</tt> class and add more
+   features.</li>
 
+<li>Implement a minimum-cost maximum-flow algorithm.</li>
+
+<li>Make the <tt>type</tt> of all (internal) property maps convertible to the <tt>const_type</tt> of the property maps.<li>
+
+<li>Add static functions to <tt>adjacency_list</tt> to return the per-vertex, per-edge, and per-graph overhead.</li>
 </ul>
 
 <br>
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>, Univ.of Notre Dame (<A HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
 </TD></TR></TABLE>
 
 </BODY>

doc/circle_layout.html

@@ -0,0 +1,51 @@
+<html><!--
+     Copyright (c) 2004 Trustees of Indiana University
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<head><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><title>Function template circle_graph_layout</title></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><table cellpadding="2" width="100%"><td valign="top"><img src="../../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86"></td><td align="center"><a href="../../../index.htm">Home</a></td><td align="center"><a href="../../libraries.htm">Libraries</a></td><td align="center"><a href="http://www.boost.org/people/people.htm">People</a></td><td align="center"><a href="http://www.boost.org/more/faq.htm">FAQ</a></td><td align="center"><a href="../../../more/index.htm">More</a></td></table><hr><div class="refentry" lang="en"><a name="id103562-bb"></a><div class="titlepage"><div></div><div></div></div><div class="refnamediv"><h2><img src="figs/python.gif" alt="(Python)"/><span class="refentrytitle">Function template circle_graph_layout</span></h2><p>boost::circle_graph_layout &#8212; Layout the graph with the vertices at the points of a regular n-polygon. </p></div><h2 xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="refsynopsisdiv-title">Synopsis</h2><div xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="refsynopsisdiv"><pre class="synopsis">
+<span class="bold"><b>template</b></span>&lt;<span class="bold"><b>typename</b></span> VertexListGraph, <span class="bold"><b>typename</b></span> PositionMap, <span class="bold"><b>typename</b></span> Radius&gt; 
+  <span class="type"><span class="bold"><b>void</b></span></span> circle_graph_layout(<span class="bold"><b>const</b></span> VertexListGraph &amp; g, PositionMap position, 
+                           Radius radius);</pre></div><div class="refsect1" lang="en"><a name="id821794"></a><h2>Where Defined</h2><a href="../../../boost/graph/circle_layout.hpp">boost/graph/circle_layout.hpp</a><h2>Description</h2><p>The distance from the center of the polygon to each point is determined by the <tt class="computeroutput">radius</tt>  parameter. The <tt class="computeroutput">position</tt>  parameter must be an Lvalue Property Map whose value type is a class type containing <tt class="computeroutput">x</tt>  and <tt class="computeroutput">y</tt>  members that will be set to the <tt class="computeroutput">x</tt>  and <tt class="computeroutput">y</tt>  coordinates. 
+
+          <h2>Parameters</h2>
+IN: <tt>const VertexListGraph&amp; g</tt>
+<blockquote>
+  The graph object on which the algorithm will be applied.  The type
+  <tt>VertexListGraph</tt> must be a model of <a
+  href="VertexListGraph.html">Vertex List Graph</a>.<br>
+<b>Python</b>: The parameter is named <tt>graph</tt>.
+</blockquote>
+
+OUT: <tt>PositionMap position</tt>
+<blockquote>
+  This property map is used to store the position of each vertex.  The
+  type <tt>PositionMap</tt> must be a model of <a
+  href="../../property_map/doc/WritablePropertyMap.html">Writable Property
+  Map</a>, with the graph's edge descriptor type as its key type. The
+  value type of this property map should be assignable from the
+  type <tt>Radius</tt>. <br>
+
+  <b>Python</b>: The position map must be a <tt>vertex_point2d_map</tt> for
+  the graph.<br>
+  <b>Python default</b>: <tt>graph.get_vertex_point2d_map("position")</tt>
+</blockquote>
+
+IN: <tt>Radius radius</tt>
+<blockquote>
+  This is the radius of the circle on which points will be layed
+  out. It must be compatible with <tt>double</tt>.<br>
+</blockquote>
+
+</p></div></div><table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr><td align="left"></td><td align="right"><small></small></td></tr></table><hr>
+
+                           <TABLE>
+<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="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

@@ -0,0 +1,971 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<!--
+     Copyright (c) 2005-2009 Trustees of Indiana University
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+  <head>
+    <title>Compressed Sparse Row Graph</title>
+
+    <STYLE TYPE="text/css">
+      <!--
+        .indent
+        {
+          padding-left: 50pt;
+          padding-right: 50pt;
+        }
+       -->
+    </STYLE>
+
+<script language="JavaScript" type="text/JavaScript">
+<!--
+function address(host, user) {
+        var atchar = '@';
+        var thingy = user+atchar+host;
+        thingy = '<a hre' + 'f=' + "mai" + "lto:" + thingy + '>' + user+atchar+host + '</a>';
+        document.write(thingy);
+}
+//-->
+</script>
+
+  </head>
+  
+  <body>
+    <IMG SRC="../../../boost.png" 
+      ALT="C++ Boost" width="277" height="86"></img>
+    <h1>Compressed Sparse Row Graph</h1>
+          
+    <p>The class template <code>compressed_sparse_row_graph</code> is
+    a graph class that uses the compact Compressed Sparse Row (CSR)
+    format to store directed (and bidirectional) graphs. While CSR graphs have
+    much less
+    overhead than many other graph formats (e.g., <a
+    href="adjacency_list.html"><code>adjacency_list</code></a>), they
+    do not provide any mutability: one cannot add or remove vertices
+    or edges from a CSR graph. Use this format in high-performance
+    applications or for very large graphs that you do not need to
+    change.</p>
+
+    <p>The CSR format stores vertices and edges in separate arrays,
+    with the indices into these arrays corresponding to the identifier
+    for the vertex or edge, respectively. The edge array is sorted by
+    the source of each edge, but contains only the targets for the
+    edges. The vertex array stores offsets into the edge array,
+    providing the offset of the first edge outgoing from each
+    vertex. Iteration over the out-edges for the <i>i</i><sup>th</sup>
+    vertex in the graph is achieved by
+    visiting <tt>edge_array[vertex_array[i]]</tt>,
+    <tt>edge_array[vertex_array[i]+1]</tt>,
+    ..., <tt>edge_array[vertex_array[i+1]]</tt>. This format minimizes
+    memory use to <i>O(n + m)</i>, where <i>n</i> and <i>m</i> are the
+    number of vertices and edges, respectively. The constants
+    multiplied by <i>n</i> and <i>m</i> are based on the size of the
+    integers needed to represent indices into the edge and vertex
+    arrays, respectively, which can be controlled using
+    the <a href="#template-parms">template parameters</a>.  The
+    <tt>Directed</tt> template parameter controls whether one edge direction
+    (the default) or both directions are stored.  A directed CSR graph has
+    <tt>Directed</tt> = <tt>directedS</tt> and a bidirectional CSR graph (with
+    a limited set of constructors)
+    has <tt>Directed</tt> = <tt>bidirectionalS</tt>.</p>
+
+    <ul>
+      <li><a href="#synopsis">Synopsis</a></li>
+      <li><a href="#where">Where Defined</a></li>
+      <li><a href="#models">Models</a></li>
+      <li><a href="#template-parms">Template parameters</a></li>
+      <li><a href="#properties">Properties</a></li>
+      <li><a href="#member-functions">Member functions</a>
+        <ul>
+          <li><a href="#constructors">Constructors</a></li>
+          <li><a href="#mutators">Mutators</a></li>
+          <li><a href="#property-access">Property access</a></li>
+        </ul></li>
+
+      <li><a href="#non-members">Non-member functions</a>
+        <ul>
+          <li><a href="#vertex-access">Vertex access</a></li>
+          <li><a href="#edge-access">Edge access</a></li>
+          <li><a href="#property-map-accessors">Property map accessors</a></li>
+          <li><a href="#incremental-construction-functions">Incremental construction functions</a></li>
+        </ul></li>
+
+      <li><a href="#example">Example</a></li>
+    </ul>
+
+    <a name="synopsis"></a><h2>Synopsis</h2>
+
+    <pre>
+namespace boost {
+
+template&lt;typename <a href="#Directed">Directed</a> = directedS, typename <a href="#VertexProperty">VertexProperty</a> = no_property, 
+         typename <a href="#EdgeProperty">EdgeProperty</a> = no_property, typename <a href="#GraphProperty">GraphProperty</a> = no_property, 
+         typename <a href="#Vertex">Vertex</a> = std::size_t, typename <a href="#EdgeIndex">EdgeIndex</a> = Vertex&gt;
+class compressed_sparse_row_graph
+{
+public:
+  <i>// <a href="#constructors">Graph constructors</a></i>
+  <a href="#default-const">compressed_sparse_row_graph</a>();
+
+  <i>// Unsorted edge list constructors </i>
+  template&lt;typename InputIterator&gt;
+  <a href="#edge-const">compressed_sparse_row_graph</a>(edges_are_unsorted_t,
+                              InputIterator edge_begin, InputIterator edge_end,
+                              vertices_size_type numverts,
+                              const GraphProperty&amp; prop = GraphProperty());
+
+  template&lt;typename InputIterator, typename EdgePropertyIterator&gt;
+  <a href="#edge-prop-const">compressed_sparse_row_graph</a>(edges_are_unsorted_t,
+                              InputIterator edge_begin, InputIterator edge_end,
+                              EdgePropertyIterator ep_iter,
+                              vertices_size_type numverts,
+                              const GraphProperty&amp; prop = GraphProperty());
+
+  template&lt;typename MultiPassInputIterator&gt;
+  <a href="#edge-multi-const">compressed_sparse_row_graph</a>(edges_are_unsorted_multi_pass_t,
+                              MultiPassInputIterator edge_begin, MultiPassInputIterator edge_end,
+                              vertices_size_type numverts,
+                              const GraphProperty&amp; prop = GraphProperty());
+
+  template&lt;typename MultiPassInputIterator, typename EdgePropertyIterator&gt;
+  <a href="#edge-multi-prop-const">compressed_sparse_row_graph</a>(edges_are_unsorted_multi_pass_t,
+                              MultiPassInputIterator edge_begin, MultiPassInputIterator edge_end,
+                              EdgePropertyIterator ep_iter,
+                              vertices_size_type numverts,
+                              const GraphProperty&amp; prop = GraphProperty());
+
+  <i>// New sorted edge list constructors <b>(directed only)</b></i>
+  template&lt;typename InputIterator&gt;
+  <a href="#edge-sorted-const">compressed_sparse_row_graph</a>(edges_are_sorted_t,
+                              InputIterator edge_begin, InputIterator edge_end,
+                              vertices_size_type numverts,
+                              edges_size_type numedges = 0,
+                              const GraphProperty&amp; prop = GraphProperty());
+
+  template&lt;typename InputIterator, typename EdgePropertyIterator&gt;
+  <a href="#edge-sorted-prop-const">compressed_sparse_row_graph</a>(edges_are_sorted_t,
+                              InputIterator edge_begin, InputIterator edge_end,
+                              EdgePropertyIterator ep_iter,
+                              vertices_size_type numverts,
+                              edges_size_type numedges = 0,
+                              const GraphProperty&amp; prop = GraphProperty());
+
+  <i>// In-place unsorted edge list constructors <b>(directed only)</b></i>
+  template&lt;typename InputIterator&gt;
+  <a href="#edge-inplace-const">compressed_sparse_row_graph</a>(construct_inplace_from_sources_and_targets_t,
+                              std::vector&lt;vertex_descriptor&gt;&amp; sources,
+                              std::vector&lt;vertex_descriptor&gt;&amp; targets,
+                              vertices_size_type numverts,
+                              const GraphProperty&amp; prop = GraphProperty());
+
+  template&lt;typename InputIterator&gt;
+  <a href="#edge-inplace-prop-const">compressed_sparse_row_graph</a>(construct_inplace_from_sources_and_targets_t,
+                              std::vector&lt;vertex_descriptor&gt;&amp; sources,
+                              std::vector&lt;vertex_descriptor&gt;&amp; targets,
+                              std::vector&lt;EdgeProperty&gt;&amp; edge_props,
+                              vertices_size_type numverts,
+                              const GraphProperty&amp; prop = GraphProperty());
+
+  <i>// Miscellaneous constructors <b>(directed only)</b></i>
+  template&lt;typename Graph, typename VertexIndexMap&gt;
+  <a href="#graph-const">compressed_sparse_row_graph</a>(const Graph&amp; g, const VertexIndexMap&amp; vi,
+                              vertices_size_type numverts,
+                              edges_size_type numedges); 
+
+  template&lt;typename Graph, typename VertexIndexMap&gt;
+  compressed_sparse_row_graph(const Graph&amp; g, const VertexIndexMap&amp; vi);
+
+  template&lt;typename Graph&gt;
+  explicit <a href="#graph-const">compressed_sparse_row_graph</a>(const Graph&amp; g);
+
+  <i>// <a href="#mutators">Graph mutators <b>(directed only)</b></a></i>
+  template&lt;typename Graph, typename VertexIndexMap&gt;
+  void <a href="#assign">assign</a>(const Graph&amp; g, const VertexIndexMap&amp; vi,
+              vertices_size_type numverts, edges_size_type numedges);
+
+  template&lt;typename Graph, typename VertexIndexMap&gt;
+  void <a href="#assign">assign</a>(const Graph&amp; g, const VertexIndexMap&amp; vi);
+
+  template&lt;typename Graph&gt;
+  void <a href="#assign">assign</a>(const Graph&amp; g);
+
+  <i>// <a href="#property-access">Property Access</a></i>
+  VertexProperty&amp; <a href="#vertex-subscript">operator[]</a>(vertex_descriptor v);
+  const VertexProperty&amp; <a href="#vertex-subscript">operator[]</a>(vertex_descriptor v) const;
+  EdgeProperty&amp; <a href="#edge-subscript">operator[]</a>(edge_descriptor v);
+  const EdgeProperty&amp; <a href="#edge-subscript">operator[]</a>(edge_descriptor v) const;
+};
+
+<i>// <a href="IncidenceGraph.html">Incidence Graph requirements</a></i>
+vertex_descriptor source(edge_descriptor, const compressed_sparse_row_graph&amp;);
+vertex_descriptor target(edge_descriptor, const compressed_sparse_row_graph&amp;);
+std::pair&lt;out_edge_iterator, out_edge_iterator&gt; 
+  out_edges(vertex_descriptor, const compressed_sparse_row_graph&amp;);
+degree_size_type out_degree(vertex_descriptor v, const compressed_sparse_row_graph&amp;);
+
+<i>// <a href="BidirectionalGraph.html">Bidirectional Graph requirements <b>(bidirectional only)</b></a></i>
+std::pair&lt;in_edge_iterator, in_edge_iterator&gt; 
+  in_edges(vertex_descriptor, const compressed_sparse_row_graph&amp;);
+degree_size_type in_degree(vertex_descriptor v, const compressed_sparse_row_graph&amp;);
+
+<i>// <a href="AdjacencyGraph.html">Adjacency Graph requirements</a></i>
+std::pair&lt;adjacency_iterator, adjacency_iterator&gt; 
+  adjacent_vertices(vertex_descriptor, const compressed_sparse_row_graph&amp;);
+
+<i>// <a href="VertexListGraph.html">Vertex List Graph requirements</a></i>
+std::pair&lt;vertex_iterator, vertex_iterator&gt; vertices(const compressed_sparse_row_graph&amp;);
+vertices_size_type num_vertices(const compressed_sparse_row_graph&amp;);
+
+<i>// <a href="EdgeListGraph.html">Edge List Graph requirements</a></i>
+std::pair&lt;edge_iterator, edge_iterator&gt; edges(const compressed_sparse_row_graph&amp;);
+edges_size_type num_edges(const compressed_sparse_row_graph&amp;);
+
+<i>// <a href="#vertex-access">Vertex access</a></i>
+vertex_descriptor <a href="#vertex-lookup">vertex</a>(vertices_size_type i, const compressed_sparse_row_graph&amp;);
+
+<i>// <a href="#edge-access">Edge access</a></i>
+std::pair&lt;edge_descriptor, bool&gt; 
+  <a href="#edge">edge</a>(vertex_descriptor u, vertex_descriptor v, const compressed_sparse_row_graph&amp;);
+edge_descriptor <a href="#edge_from_index">edge_from_index</a>(edges_size_type i, const compressed_sparse_row_graph&amp;);
+
+<i>// <a href="#property-map-accessors">Property map accessors</a></i>
+template&lt;typename <a href="./PropertyTag.html">PropertyTag</a>&gt;
+property_map&lt;compressed_sparse_row_graph, PropertyTag&gt;::type
+<a href="#get">get</a>(PropertyTag, compressed_sparse_row_graph&amp; g)
+
+template&lt;typename <a href="./PropertyTag.html">PropertyTag</a>&gt;
+property_map&lt;compressed_sparse_row_graph, Tag&gt;::const_type
+<a href="#get">get</a>(PropertyTag, const compressed_sparse_row_graph&amp; g)
+
+template&lt;typename <a href="./PropertyTag.html">PropertyTag</a>, class X&gt;
+typename property_traits&lt;property_map&lt;compressed_sparse_row_graph, PropertyTag&gt;::const_type&gt;::value_type
+<a href="#get-x">get</a>(PropertyTag, const compressed_sparse_row_graph&amp; g, X x)
+
+template&lt;typename <a href="./PropertyTag.html">PropertyTag</a>, class X, class Value&gt;
+void <a href="#put-x">put</a>(PropertyTag, const compressed_sparse_row_graph&amp; g, X x, const Value&amp; value);
+
+template&lt;typename <a href="./PropertyTag.html#GraphPropertyTag">GraphPropertyTag</a>&gt;
+typename graph_property&lt;compressed_sparse_row_graph, GraphPropertyTag&gt;::type&amp;
+<a href="#get_property">get_property</a>(compressed_sparse_row_graph&amp; g, GraphPropertyTag);
+
+template&lt;typename <a href="./PropertyTag.html#GraphPropertyTag">GraphPropertyTag</a>&gt;
+typename graph_property&lt;compressed_sparse_row_graph, GraphPropertyTag&gt;::type const &amp;
+<a href="#get_property">get_property</a>(const compressed_sparse_row_graph&amp; g, GraphPropertyTag);
+
+template&lt;typename <a href="./PropertyTag.html#GraphPropertyTag">GraphPropertyTag</a>&gt;
+void <a href="#set_property">set_property</a>(const compressed_sparse_row_graph&amp; g, GraphPropertyTag,
+                  const typename graph_property&lt;compressed_sparse_row_graph, GraphPropertyTag&gt;::type&amp; value);
+
+<i>// <a href="#incremental-construction-functions">Incremental construction functions</a></i>
+<b>(directed only)</b>
+template&lt;typename InputIterator, typename Graph&gt;
+void <a href="#add_edges">add_edges</a>(InputIterator first, InputIterator last, compressed_sparse_row_graph&amp; g);
+
+<b>(directed only)</b>
+template&lt;typename InputIterator, typename EPIter, typename Graph&gt;
+void <a href="#add_edges_prop">add_edges</a>(InputIterator first, InputIterator last, EPIter ep_first, EPIter ep_last, compressed_sparse_row_graph&amp; g);
+
+<b>(directed only)</b>
+template&lt;typename BidirectionalIterator, typename Graph&gt;
+void <a href="#add_edges_sorted">add_edges_sorted</a>(BidirectionalIterator first, BidirectionalIterator last, compressed_sparse_row_graph&amp; g);
+
+<b>(directed only)</b>
+template&lt;typename BidirectionalIterator, typename EPIter, typename Graph&gt;
+void <a href="#add_edges_sorted_prop">add_edges_sorted</a>(BidirectionalIterator first, BidirectionalIterator last, EPIter ep_iter, compressed_sparse_row_graph&amp; g);
+
+} <i>// end namespace boost</i>
+   </pre>
+
+    <a name="where"></a><h2>Where Defined</h2>
+    <p><code>&lt;<a href="../../../boost/graph/compressed_sparse_row_graph.hpp">boost/graph/compressed_sparse_row_graph.hpp</a>&gt;</code></p>
+
+    <a name="models"></a><h2>Models</h2>
+    
+    <p>The <tt>compressed_sparse_row_graph</tt> class template models
+    (i.e., implements the requirements of) many of the
+    BGL <a href="graph_concepts.html">graph concepts</a>, allowing it
+    to be used with most of the BGL algorithms. In particular, it
+    models the following specific graph concepts:</p>
+
+    <ul>
+      <li><a href="Graph.html">Graph</a></li>
+      <li><a href="IncidenceGraph.html">IncidenceGraph</a></li>
+      <li><a href="AdjacencyGraph.html">AdjacencyGraph</a></li>
+      <li><a href="VertexListGraph.html">VertexListGraph</a></li>
+      <li><a href="EdgeListGraph.html">EdgeListGraph</a></li>
+      <li><a href="PropertyGraph.html">PropertyGraph</a></li>
+    </ul>
+
+    <a name="template-parms"></a><h2>Template Parameters</h2>
+
+    <p>The <tt>compressed_sparse_row_graph</tt> class has several
+      template parameters that can customize the layout in memory and
+      what properties are attached to the graph itself. All
+      parameters have defaults, so users interested only in the
+      structure of a graph can use the
+      type <tt>compressed_sparse_row_graph&lt;&gt;</tt> and ignore
+      the parameters.</p>
+
+    <b>Parameters</b>
+    <br>
+    <br>
+
+    <a name="Directed"></a><code>Directed</code>
+      <blockquote>
+        A selector that determines whether the graph will be directed,
+        bidirectional or undirected. At this time, the CSR graph type
+        only supports directed and bidirectional graphs, so this value must
+        be either <code>boost::directedS</code> or
+        <code>boost::bidirectionalS</code>.<br>
+        <b>Default</b>: <code>boost::directedS</code>
+      </blockquote>
+
+    <a name="VertexProperty"></a><code>VertexProperty</code>
+      <blockquote>
+        A class type that will be
+        attached to each vertex in the graph. If this value
+        is <code>void</code>, no properties will be attached to
+        the vertices of the graph.<br>
+        <b>Default</b>: <code>void</code>
+      </blockquote>
+
+    <a name="EdgeProperty"></a><code>EdgeProperty</code>
+    <blockquote>
+      A class type that will be attached to each edge in the graph. If
+        this value is <code>void</code>, no properties will be
+        attached to the edges of the graph.<br>
+        <b>Default</b>: <code>void</code>
+    </blockquote>
+
+    <a name="GraphProperty"></a><code>GraphProperty</code>
+    <blockquote>
+      A nested set
+        of <code>property</code> templates that describe the
+        properties of the graph itself.  If this value
+        is <code>no_property</code>, no properties will be attached to
+        the graph.<br>
+        <b>Default</b>: <code>no_property</code>
+    </blockquote>
+
+    <a name="Vertex"></a><code>Vertex</code>
+    <blockquote>
+      An unsigned integral type that will be
+      used as both the index into the array of vertices and as the
+      vertex descriptor itself. Larger types permit the CSR graph to
+      store more vertices; smaller types reduce the storage required
+      per vertex.<br>
+        <b>Default</b>: <code>std::size_t</code>
+    </blockquote>
+
+    <a name="EdgeIndex"></a><code>EdgeIndex</code>
+    <blockquote>
+      An unsigned integral type that will be used as the index into
+        the array of edges. As with the <code>Vertex</code> parameter,
+        larger types permit more edges whereas smaller types reduce
+        the amount of storage needed per
+        edge. The <code>EdgeIndex</code> type shall not be smaller
+        than the <code>Vertex</code> type, but it may be larger. For
+        instance, <code>Vertex</code> may be a 16-bit integer
+        (allowing 32,767 vertices in the graph)
+        whereas <code>EdgeIndex</code> could then be a 32-bit integer
+        to allow a complete graph to be stored in the CSR format.<br>
+        <b>Default</b>: <code>Vertex</code>
+    </blockquote>
+
+    <a name="properties"></a><h2>Interior Properties</h2>
+
+    <p> The <tt>compressed_sparse_row_graph</tt> allows properties to
+    be attached to its vertices, edges, or to the graph itself by way
+    of its <a href="#template-parms">template parameters</a>. These
+    properties may be accessed via
+    the <a href="#property-access">member</a>
+    and <a href="#property-map-accessors">non-member</a> property
+    access functions, using the <a href="bundles.html">bundled
+    properties</a> scheme.</p>
+
+    <p>The CSR graph provides two kinds of built-in
+    properties: <tt>vertex_index</tt>, which maps from vertices to
+      values in <tt>[0, n)</tt> and <tt>edge_index</tt>, which maps
+      from edges to values in <tt>[0, m)</tt>, where <tt>n</tt>
+    and <tt>m</tt> are the number of vertices and edges in the graph,
+    respectively. </p>
+
+    <a name="member-functions"></a><h2>Member Functions</h2>
+
+    <a name="constructors"></a><h3>Constructors</h3>
+    <pre><a name="default-const"></a>
+  compressed_sparse_row_graph();
+    </pre>
+    <p class="indent">Constructs a graph with no vertices or edges.</p>
+
+    <hr></hr>
+
+    <pre><a name="edge-const"></a>
+  template&lt;typename InputIterator&gt;
+  compressed_sparse_row_graph(edges_are_unsorted_t,
+                              InputIterator edge_begin, InputIterator edge_end,
+                              vertices_size_type numverts,
+                              const GraphProperty&amp; prop = GraphProperty());
+    </pre>
+
+    <p class="indent">
+      Constructs a graph with <code>numverts</code> vertices whose
+      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.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,
+      numverts)</code>. The edges in <code>[edge_begin,
+      edge_end)</code> do not need to be sorted.  This constructor uses extra
+      memory to save the edge information before adding it to the graph,
+      avoiding the requirement for the iterator to have multi-pass capability.
+    </p>
+
+    <p class="indent">
+      The value <code>prop</code> will be used to initialize the graph
+      property.
+    </p>
+
+    <hr></hr>
+
+    <pre><a name="edge-prop-const"></a>
+  template&lt;typename InputIterator, typename EdgePropertyIterator&gt;
+  compressed_sparse_row_graph(edges_are_unsorted_t,
+                              InputIterator edge_begin, InputIterator edge_end,
+                              EdgePropertyIterator ep_iter,
+                              vertices_size_type numverts,
+                              const GraphProperty&amp; prop = GraphProperty());
+    </pre>
+    <p class="indent">
+      This constructor constructs a graph with <code>numverts</code>
+      vertices and the edges provided in the iterator range
+      <code>[edge_begin, edge_end)</code>. Its semantics are identical
+      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.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
+      of the graph, where <tt>m</tt> is distance from
+      <tt>edge_begin</tt> to <tt>edge_end</tt>.  This constructor uses extra
+      memory to save the edge information before adding it to the graph,
+      avoiding the requirement for the iterator to have multi-pass capability.
+    </p>
+
+    <hr></hr>
+
+    <pre><a name="edge-multi-const"></a>
+  template&lt;typename MultiPassInputIterator&gt;
+  compressed_sparse_row_graph(edges_are_unsorted_multi_pass_t,
+                              MultiPassInputIterator edge_begin, MultiPassInputIterator edge_end,
+                              vertices_size_type numverts,
+                              const GraphProperty&amp; prop = GraphProperty());
+    </pre>
+
+    <p class="indent">
+      Constructs a graph with <code>numverts</code> vertices whose
+      edges are specified by the iterator range <code>[edge_begin,
+      edge_end)</code>. The <tt>MultiPassInputIterator</tt> must be a model of
+      <a
+      href="../../utility/MultiPassInputIterator.html">MultiPassInputIterator</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,
+      numverts)</code>. The edges in <code>[edge_begin,
+      edge_end)</code> do not need to be sorted.  Multiple passes will be made
+      over the edge range.
+    </p>
+
+    <p class="indent">
+      The value <code>prop</code> will be used to initialize the graph
+      property.
+    </p>
+
+    <hr></hr>
+
+    <pre><a name="edge-multi-prop-const"></a>
+  template&lt;typename MultiPassInputIterator, typename EdgePropertyIterator&gt;
+  compressed_sparse_row_graph(edges_are_unsorted_multi_pass_t,
+                              MultiPassInputIterator edge_begin, MultiPassInputIterator edge_end,
+                              EdgePropertyIterator ep_iter,
+                              vertices_size_type numverts,
+                              const GraphProperty&amp; prop = GraphProperty());
+    </pre>
+    <p class="indent">
+      This constructor constructs a graph with <code>numverts</code>
+      vertices and the edges provided in the iterator range
+      <code>[edge_begin, edge_end)</code>. Its semantics are identical
+      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="../../utility/MultiPassInputIterator.html">MultiPassInputIterator</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
+      of the graph, where <tt>m</tt> is distance from
+      <tt>edge_begin</tt> to <tt>edge_end</tt>.  Multiple passes will be made
+      over the edge and property ranges.
+    </p>
+
+    <hr></hr>
+
+    <pre><a name="edge-sorted-const"></a>
+  template&lt;typename InputIterator&gt;
+  compressed_sparse_row_graph(edges_are_sorted_t,
+                              InputIterator edge_begin, InputIterator edge_end,
+                              vertices_size_type numverts,
+                              edges_size_type numedges = 0,
+                              const GraphProperty&amp; prop = GraphProperty());
+    </pre>
+
+    <p class="indent">
+      Constructs a graph with <code>numverts</code> vertices whose
+      edges are specified by the iterator range <code>[edge_begin,
+      edge_end)</code>. The argument of type <code>edges_are_sorted_t</code> is
+      a tag used to distinguish this constructor; the value
+      <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.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,
+      numverts)</code>. The edges in <code>[edge_begin,
+      edge_end)</code> must be sorted so that all edges originating
+      from vertex <i>i</i> precede any edges originating from all
+      vertices <i>j</i> where <i>j &gt; i</i>.
+    </p>
+
+    <p class="indent">
+      The value <code>numedges</code>, if provided, tells how many
+      edges are in the range <code>[edge_begin, edge_end)</code> and
+      will be used to preallocate data structures to save both memory
+      and time during construction.
+    </p>
+
+    <p class="indent">
+      The value <code>prop</code> will be used to initialize the graph
+      property.
+    </p>
+
+    <hr></hr>
+
+    <pre><a name="edge-sorted-prop-const"></a>
+  template&lt;typename InputIterator, typename EdgePropertyIterator&gt;
+  compressed_sparse_row_graph(edges_are_sorted_t,
+                              InputIterator edge_begin, InputIterator edge_end,
+                              EdgePropertyIterator ep_iter,
+                              vertices_size_type numverts,
+                              edges_size_type numedges = 0,
+                              const GraphProperty&amp; prop = GraphProperty());
+    </pre>
+    <p class="indent">
+      This constructor constructs a graph with <code>numverts</code>
+      vertices and the edges provided in the iterator range
+      <code>[edge_begin, edge_end)</code>. Its semantics are identical
+      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.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
+      of the graph, where <tt>m</tt> is distance from
+      <tt>edge_begin</tt> to <tt>edge_end</tt>.
+    </p>
+
+    <hr></hr>
+
+    <pre><a name="edge-inplace-const"></a>
+  template&lt;typename InputIterator&gt;
+  compressed_sparse_row_graph(construct_inplace_from_sources_and_targets_t,
+                              std::vector&lt;vertex_descriptor&gt;&amp; sources,
+                              std::vector&lt;vertex_descriptor&gt;&amp; targets,
+                              vertices_size_type numverts,
+                              const GraphProperty&amp; prop = GraphProperty());
+    </pre>
+    <p class="indent">
+      This constructor constructs a graph with <code>numverts</code> vertices
+      and the edges provided in the two vectors <code>sources</code> and
+      <code>targets</code>.  The two vectors are mutated in-place to sort them
+      by source vertex.  They are returned with unspecified values, but do not
+      share storage with the constructed graph (and so are safe to destroy).
+      The parameter <code>prop</code>, if provided, is used to initialize the
+      graph property.
+    </p>
+
+    <hr></hr>
+
+    <pre><a name="edge-inplace-prop-const"></a>
+  template&lt;typename InputIterator&gt;
+  compressed_sparse_row_graph(construct_inplace_from_sources_and_targets_t,
+                              std::vector&lt;vertex_descriptor&gt;&amp; sources,
+                              std::vector&lt;vertex_descriptor&gt;&amp; targets,
+                              std::vector&lt;EdgeProperty&gt;&amp; edge_props,
+                              vertices_size_type numverts,
+                              const GraphProperty&amp; prop = GraphProperty());
+    </pre>
+    <p class="indent">
+      This constructor constructs a graph with <code>numverts</code> vertices
+      and the edges provided in the two vectors <code>sources</code> and
+      <code>targets</code>.  Edge properties are initialized from the vector
+      <code>edge_props</code>.  The three vectors are mutated in-place to sort
+      them by source vertex.  They are returned with unspecified values, but do
+      not share storage with the constructed graph (and so are safe to
+      destroy).  The parameter <code>prop</code>, if provided, is used to
+      initialize the graph property.
+    </p>
+
+    <hr></hr>
+
+    <pre><a name="graph-const"></a>
+  template&lt;typename Graph, typename VertexIndexMap&gt;
+  compressed_sparse_row_graph(const Graph&amp; g, const VertexIndexMap&amp; vi,
+                              vertices_size_type numverts,
+                              edges_size_type numedges); 
+
+  template&lt;typename Graph, typename VertexIndexMap&gt;
+  compressed_sparse_row_graph(const Graph&amp; g, const VertexIndexMap&amp; vi);
+
+  template&lt;typename Graph&gt;
+  explicit compressed_sparse_row_graph(const Graph&amp; g);
+    </pre>
+
+    <p class="indent">
+      Calls the <a href="#assign"><tt>assign</tt></a> function with
+      all of the arguments it is given.
+    </p>
+
+    <hr></hr>
+
+    <a name="mutators"></a><h3>Mutators</h3>
+    <pre><a name="assign"></a>
+  template&lt;typename Graph, typename VertexIndexMap&gt;
+  void assign(const Graph&amp; g, const VertexIndexMap&amp; vi,
+              vertices_size_type numverts, edges_size_type numedges);
+
+  template&lt;typename Graph, typename VertexIndexMap&gt;
+  void assign(const Graph&amp; g, const VertexIndexMap&amp; vi);
+
+  template&lt;typename Graph&gt;
+  void assign(const Graph&amp; g);
+    </pre>
+
+    <p class="indent">
+      Clears the CSR graph and builds a CSR graph in place from the
+      structure of another graph. The graph type <tt>Graph</tt> must
+      be a model of <a href="IncidenceGraph.html">IncidenceGraph</a>.
+
+      <br><b>Parameters</b>
+
+      <ul>
+        <li><tt>g</tt>: The incoming graph.</li>
+        
+        <li><tt>vi</tt>: A map from vertices to indices. If not
+          provided, <tt>get(vertex_index, g)</tt> will be used.</li>
+        
+        <li><tt>numverts</tt>: The number of vertices in the graph
+          <tt>g</tt>. If not provided, <tt>Graph</tt> must be a model of
+          <a href="VertexListGraph.html">VertexListGraph</a>.</li>
+        
+        <li><tt>numedges</tt>: The number of edges in the graph
+          <tt>g</tt>. If not provided, <tt>Graph</tt> must be a model of
+          <a href="EdgeListGraph.html">EdgeListGraph</a>.</li>
+      </ul>
+    </p>
+
+    <hr></hr>
+
+    <a name="property-access"></a><h3>Property Access</h3>
+
+    <pre><a name="vertex-subscript"></a>
+  VertexProperty&amp; operator[](vertex_descriptor v);
+  const VertexProperty&amp; operator[](vertex_descriptor v) const;
+    </pre>
+
+    <p class="indent">
+      Retrieves the property value associated with vertex
+      <tt>v</tt>. Only valid when <tt>VertexProperty</tt> is a class
+      type that is not <tt>no_property</tt>.
+    </p>
+
+    <hr></hr>
+
+    <pre><a name="edge-subscript">
+  EdgeProperty&amp; operator[](edge_descriptor v);
+  const EdgeProperty&amp; operator[](edge_descriptor v) const;
+    </pre>
+
+    <p class="indent">
+      Retrieves the property value associated with edge
+      <tt>v</tt>. Only valid when <tt>EdgeProperty</tt> is a class
+      type that is not <tt>no_property</tt>.
+    </p>
+
+    <hr></hr>
+    <a name="non-members"></a><h2>Non-member Functions</h2>
+
+    <a name="vertex-access"></a><h3>Vertex access</h3>
+
+    <pre><a name="vertex-lookup"></a>
+  vertex_descriptor vertex(vertices_size_type i, const compressed_sparse_row_graph&amp;);
+    </pre>
+    <p class="indent">
+      Retrieves the <i>i</i><sup>th</sup> vertex in the graph in
+      constant time.
+    </p>
+
+    <hr></hr>
+
+    <a name="edge-access"></a><h3>Edge access</h3>
+
+    <pre><a name="edge"></a>
+  std::pair&lt;edge_descriptor, bool&gt; 
+    edge(vertex_descriptor u, vertex_descriptor v, const compressed_sparse_row_graph&amp;);
+    </pre>
+
+    <p class="indent">
+      If there exists an edge <i>(u, v)</i> in the graph, returns the
+      descriptor for that edge and <tt>true</tt>; otherwise, the
+      second value in the pair will be <tt>false</tt>. If multiple
+      edges exist from <tt>u</tt> to <tt>v</tt>, the first edge will
+      be returned; use <a href="IncidenceGraph.html"><tt>out_edges</tt></a> and a
+      conditional statement
+      to retrieve all edges to a given target.  This function requires linear
+      time in the
+      number of edges outgoing from <tt>u</tt>.
+    </p>
+
+    <hr></hr>
+
+    <pre><a name="edge_from_index"></a>
+  edge_descriptor edge_from_index(edges_size_type i, const compressed_sparse_row_graph&amp;);
+    </pre>
+
+    <p class="indent">
+      Returns the <i>i</i><sup>th</sup> edge in the graph. This
+      operation requires logarithmic time in the number of vertices.
+    </p>
+
+    <hr></hr>
+
+    <h3><a name="property-map-accessors">Property Map Accessors</a></h3>
+
+    <pre><a name="get"></a>
+template&lt;typename <a href="./PropertyTag.html">PropertyTag</a>&gt;
+property_map&lt;compressed_sparse_row_graph, PropertyTag&gt;::type
+get(PropertyTag, compressed_sparse_row_graph&amp; g)
+
+template&lt;typename <a href="./PropertyTag.html">PropertyTag</a>&gt;
+property_map&lt;compressed_sparse_row_graph, Tag&gt;::const_type
+get(PropertyTag, const compressed_sparse_row_graph&amp; g)
+    </pre>
+    
+    <p class="indent">
+      Returns the property map object for the vertex property
+      specified by <TT>PropertyTag</TT>. The <TT>PropertyTag</TT> must
+      be a member pointer to access one of the fields in
+      <tt>VertexProperty</tt> or <tt>EdgeProperty</tt>.
+    </p>
+
+    <hr></hr>
+
+    <pre><a name="get-x"></a>
+template&lt;typename <a href="./PropertyTag.html">PropertyTag</a>, class X&gt;
+typename property_traits&lt;property_map&lt;compressed_sparse_row_graph, PropertyTag&gt;::const_type&gt::value_type
+get(PropertyTag, const compressed_sparse_row_graph&amp; g, X x)
+    </pre>
+
+    <p class="indent">
+      This returns the property value for <tt>x</tt>, where <tt>x</tt>
+      is either a vertex or edge descriptor.
+    </p>
+
+    <hr></hr>
+
+    <pre><a name="put-x"></a>
+template&lt;typename <a href="./PropertyTag.html">PropertyTag</a>, class X, class Value&gt;
+void put(PropertyTag, const compressed_sparse_row_graph&amp; g, X x, const Value&amp; value);
+    </pre>
+
+    <p class="indent">
+      This sets the property value for <tt>x</tt> to
+      <tt>value</tt>. <tt>x</tt> is either a vertex or edge
+      descriptor.  <tt>Value</tt> must be convertible to <tt>typename
+      property_traits&lt;property_map&lt;compressed_sparse_row_graph,
+      PropertyTag&gt;::type&gt::value_type</tt>
+    </p>
+
+    <hr></hr>
+
+    <pre><a name="get_property"></a>
+template&lt;typename <a href="./PropertyTag.html#GraphPropertyTag">GraphPropertyTag</a>&gt;
+typename graph_property&lt;compressed_sparse_row_graph, GraphPropertyTag&gt;::type&amp;
+get_property(compressed_sparse_row_graph&amp; g, GraphPropertyTag);
+
+template&lt;typename <a href="./PropertyTag.html#GraphPropertyTag">GraphPropertyTag</a>&gt;
+typename graph_property&lt;compressed_sparse_row_graph, GraphPropertyTag&gt;::type const &amp;
+get_property(const compressed_sparse_row_graph&amp; g, GraphPropertyTag);
+    </pre>
+
+    <p class="indent">
+      Return the property specified by <tt>GraphPropertyTag</tt> that
+      is attached to the graph object <tt>g</tt>. 
+    </p>
+
+    <hr></hr>
+
+    <pre><a name="set_property"></a>
+template&lt;typename <a href="./PropertyTag.html#GraphPropertyTag">GraphPropertyTag</a>&gt;
+void set_property(const compressed_sparse_row_graph&amp; g, GraphPropertyTag,
+                  const typename graph_property&lt;compressed_sparse_row_graph, GraphPropertyTag&gt;::type&amp; value);
+    </pre>
+
+    <p class="indent">
+      Set the property specified by <tt>GraphPropertyTag</tt> that
+      is attached to the graph object <tt>g</tt>.
+    </p>
+
+    <hr></hr>
+
+    <h3><a name="incremental-construction-functions">Incremental construction functions</a></h3>
+
+    <pre><a name="add_edges"></a>
+template&lt;typename InputIterator&gt;
+void add_edges(InputIterator first, InputIterator last, compressed_sparse_row_graph&amp; g)
+    </pre>
+    
+    <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.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.
+    </p>
+
+    <hr></hr>
+
+    <pre><a name="add_edges_prop"></a>
+template&lt;typename InputIterator, typename EPIter&gt;
+void add_edges(InputIterator first, InputIterator last, EPIter ep_first, EPIter ep_last, compressed_sparse_row_graph&amp; g)
+    </pre>
+    
+    <p class="indent">
+      Add a range of edges (from <tt>first</tt> to <tt>last</tt>) with
+      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.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
+      integer values produced by the <tt>InputIterator</tt> are the source and
+      target vertices of the new edges.  The edges do not need to be sorted.
+    </p>
+
+    <hr></hr>
+
+    <pre><a name="add_edges_sorted"></a>
+template&lt;typename BidirectionalIterator&gt;
+void add_edges_sorted(BidirectionalIterator first, BidirectionalIterator last, compressed_sparse_row_graph&amp; g)
+    </pre>
+    
+    <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.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
+      index.
+    </p>
+
+    <hr></hr>
+
+    <pre><a name="add_edges_sorted_prop"></a>
+template&lt;typename BidirectionalIterator, typename EPIter&gt;
+void add_edges_sorted(BidirectionalIterator first, BidirectionalIterator last, EPIter ep_iter, compressed_sparse_row_graph&amp; g)
+    </pre>
+    
+    <p class="indent">
+      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.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
+      new edges.
+      The <code>value_type</code> of the <tt>EPIter</tt> must be the edge
+      property type of the graph.
+      The edges must be sorted in increasing order by source vertex
+      index.
+    </p>
+
+    <hr></hr>
+    <a name="example"></a><h2>Example</h2>
+
+    <br>[<a
+    href="../example/csr-example.cpp">libs/graph/example/csr-example.cpp</a>]
+
+    <p>We will use the <tt>compressed_sparse_row_graph</tt> graph
+    class to store a simple Web graph. In this web graph the vertices
+    represent web pages and the edges represent links from one web
+    page to another. With each web page we want to associate a URL, so
+    we initially create a <tt>WebPage</tt> class that stores the
+    URL. Then we can create our graph type by providing
+    <tt>WebPage</tt> as a parameter to the
+    <tt>compressed_sparse_row_graph</tt> class template.</p>
+
+    <pre>
+class WebPage
+{
+ public:
+  std::string url;
+};
+
+// ...
+
+typedef compressed_sparse_row_graph&lt;directedS, WebPage&gt; WebGraph;
+WebGraph g(&the_edges[0], &the_edges[0] + sizeof(the_edges)/sizeof(E), 6);
+    </pre>
+
+    <p>We can then set the properties on the vertices of the graph
+    using the <a href="bundles.html">bundled properties</a> syntax,
+    and display the edges for the user.</p>
+
+    <pre>
+// Set the URLs of each vertex
+int index = 0;
+BGL_FORALL_VERTICES(v, g, WebGraph)
+  g[v].url = urls[index++];
+
+// Output each of the links
+std::cout &lt;&lt; "The web graph:" &lt;&lt; std::endl;
+BGL_FORALL_EDGES(e, g, WebGraph)
+  std::cout &lt;&lt; "  " &lt;&lt; g[source(e, g)].url &lt;&lt; " -> " &lt;&lt; g[target(e, g)].url 
+            &lt;&lt; std::endl;
+    </pre>
+
+    <p>See the <a href="../example/csr-example.cpp">complete example
+    source</a> for other operations one can perform with a
+    <tt>compressed_sparse_row_graph</tt>.</p>
+<br>
+<HR>
+<TABLE>
+<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>
+Jeremiah Willcock, Indiana University (<script language="Javascript">address("osl.iu.edu", "jewillco")</script>)<br>
+  <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>
+</html>

doc/connected_components.html

@@ -0,0 +1,157 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek 2000-2001
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Connected Components</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+
+<H1>
+<A NAME="sec:connected-components">
+<img src="figs/python.gif" alt="(Python)"/>
+<TT>connected_components</TT></A>
+</H1>
+
+<PRE>
+<i>// named parameter version</i>
+template &lt;class VertexListGraph, class ComponentMap, class P, class T, class R&gt;
+typename property_traits&lt;ComponentMap&gt;::value_type
+connected_components(VertexListGraph&amp; G, ComponentMap comp,
+    const bgl_named_params&lt;P, T, R&gt;&amp; params = <i>all defaults</i>);
+
+<i>// there is not a non-named parameter version of this function</i>
+</PRE>
+
+<P>
+The <TT>connected_components()</TT> functions compute the connected
+components of an undirected graph using a DFS-based approach.  A
+<b><I>connected component</I></b> of an undirected graph is a set of
+vertices that are all reachable from each other. If the connected
+components need to be maintained while a graph is growing the
+disjoint-set based approach of function <a
+href="./incremental_components.html">
+<TT>incremental_components()</TT></a> is faster. For ``static'' graphs
+this DFS-based approach is faster&nbsp;[<A
+HREF="bibliography.html#clr90">8</A>].
+
+<P>
+The output of the algorithm is recorded in the component property map
+<TT>comp</TT>, which will contain numbers giving the component number
+assigned to each vertex. The total number of components is the return
+value of the function.
+
+<H3>Where Defined</H3>
+
+<P>
+<a href="../../../boost/graph/connected_components.hpp"><TT>boost/graph/connected_components.hpp</TT></a>
+
+
+<h3>Parameters</h3>
+
+IN: <tt>const Graph&amp; g</tt>
+<blockquote>
+An undirected graph. The graph type must be a model of <a
+href="VertexListGraph.html">Vertex List Graph</a> and <a
+href="IncidenceGraph.html">Incidence Graph</a>.<br>
+
+<b>Python</b>: The parameter is named <tt>graph</tt>.
+</blockquote>
+
+OUT: <tt>ComponentMap c</tt>
+<blockquote>
+The algorithm computes how many connected components are in the graph,
+and assigning each component an integer label. The algorithm then
+records which component each vertex in the graph belongs to by
+recording the component number in the component property map. The
+<tt>ComponentMap</tt> type must be a model of <a
+href="../../property_map/doc/WritablePropertyMap.html">Writable Property
+Map</a>. The value type should be an integer type, preferably the same
+as the <tt>vertices_size_type</tt> of the graph. The key type must be
+the graph's vertex descriptor type.<br>
+
+  <b>Python</b>: Must be an <tt>vertex_int_map</tt> for the graph.<br>
+  <b>Python default</b>: <tt>graph.get_vertex_int_map("component")</tt>
+</blockquote>
+
+<h3>Named Parameters</h3>
+
+UTIL: <tt>color_map(ColorMap color)</tt>
+<blockquote>
+  This is used by the algorithm to keep track of its progress through
+  the graph. The type <tt>ColorMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a> and its key type must be the graph's vertex
+  descriptor type and the value type of the color map must model
+  <a href="./ColorValue.html">ColorValue</a>.<br>
+  <b>Default:</b> an <a
+  href="../../property_map/doc/iterator_property_map.html">
+  </tt>iterator_property_map</tt></a> created from a
+  <tt>std::vector</tt> of <tt>default_color_type</tt> of size
+  <tt>num_vertices(g)</tt> and using the <tt>i_map</tt> for the index
+  map.<br>
+  <b>Python</b>: The color map must be a <tt>vertex_color_map</tt> for
+  the graph.
+</blockquote>
+
+IN: <tt>vertex_index_map(VertexIndexMap i_map)</tt>
+<blockquote>
+  This maps each vertex to an integer in the range <tt>[0,
+  num_vertices(g))</tt>. This parameter is only necessary when the
+  default color property map is used. The type <tt>VertexIndexMap</tt>
+  must be a model of <a
+  href="../../property_map/doc/ReadablePropertyMap.html">Readable Property
+  Map</a>. The value type of the map must be an integer type. The
+  vertex descriptor type of the graph needs to be usable as the key
+  type of the map.<br>
+
+  <b>Default:</b> <tt>get(vertex_index, g)</tt>.
+    Note: if you use this default, make sure your graph has
+    an internal <tt>vertex_index</tt> property. For example,
+    <tt>adjacency_list</tt> with <tt>VertexList=listS</tt> does
+    not have an internal <tt>vertex_index</tt> property.<br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+
+<H3>Complexity</H3>
+
+<P>
+The time complexity for the connected components algorithm is also
+<i>O(V + E)</i>.
+
+<P>
+
+<h3>See Also</h3>
+
+<a href="./strong_components.html"><tt>strong_components()</tt></a>
+and <a href="./incremental_components.html"><tt>incremental_components()</tt></a>
+
+<H3>Example</H3>
+
+<P>
+The file <a
+href="../example/connected_components.cpp"><tt>examples/connected_components.cpp</tt></a>
+contains an example of calculating the connected components of an
+undirected graph.
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 

doc/constructing_algorithms.html

@@ -1,20 +1,16 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  Silicon Graphics makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>Boost Graph Library: Constructing Graph Algorithms</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -82,9 +78,9 @@ most algorithms written to date are). We do restrict the graph type to
 those types that model <a
 href="./VertexListGraph.html">VertexListGraph</a>. This is enforced by
 the use of those graph operations in the algorithm, and furthermore by
-our explicit requirement added as a concept check with the
-<TT>REQUIRE</TT> macro (see Section <A
-HREF="../../concept_checking/concept_checking.html">Concept
+our explicit requirement added as a concept check with
+<TT>BOOST_CONCEPT_ASSERT()</TT> (see Section <A
+HREF="../../concept_check/concept_check.htm">Concept
 Checking</A> for more details about concept checking).
 
 <P>
@@ -95,12 +91,12 @@ use the propery map interface. This gives the user of the
 algorithm the ability to decide how they want to store the properties.
 Since we will need to both read and write the colors we specify the
 requirements as <a
-href="../../property_map/ReadWritePropertyMap.html">ReadWritePropertyMap</a>. The
+href="../../property_map/doc/ReadWritePropertyMap.html">ReadWritePropertyMap</a>. The
 <TT>key_type</TT> of the color map must be the
 <TT>vertex_descriptor</TT> from the graph, and the <TT>value_type</TT>
 must be some kind of integer. We also specify the interface for the
 <TT>order</TT> parameter as a property map, in this case a <a
-href="../../property_map/ReadablePropertyMap.html">ReadablePropertyMap</a>. For
+href="../../property_map/doc/ReadablePropertyMap.html">ReadablePropertyMap</a>. For
 order, the <TT>key_type</TT> is an integer offset and the
 <TT>value_type</TT> is a <TT>vertex_descriptor</TT>. Again we enforce
 these requirements with concept checks. The return value of this
@@ -110,7 +106,7 @@ hence the return type of the function is the graph's
 graph algorithm as a template function, the concept checks, and some
 typedefs. The implementation is straightforward, the only step not
 discussed above is the color initialization step, where we set the
-color of all the vertices to ``uncolored''.
+color of all the vertices to "uncolored."
 
 <P>
 <PRE>
@@ -126,11 +122,11 @@ namespace boost {
     typedef typename property_traits&lt;Color&gt;::value_type ColorType;
     typedef typename property_traits&lt;Order&gt;::value_type OrderType;
 
-    REQUIRE(VertexListGraph, VertexListGraph);
-    REQUIRE2(Color, vertex_descriptor, ReadWritePropertyMap);
-    REQUIRE(ColorType, Integer);
-    REQUIRE(Order, size_type, ReadablePropertyMap);
-    REQUIRE_SAME_TYPE(OrderType, vertex_descriptor);
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept&lt;VertexListGraph&gt; ));
+    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept&lt;Color, vertex_descriptor&gt; ));
+    BOOST_CONCEPT_ASSERT(( IntegerConcept&lt;ColorType&gt; ));
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept&lt;Order, size_type&gt; ));
+    BOOST_STATIC_ASSERT((is_same&lt;OrderType, vertex_descriptor&gt;::value));
     
     size_type max_color = 0;
     const size_type V = num_vertices(G);
@@ -138,7 +134,7 @@ namespace boost {
       mark(V, numeric_limits_max(max_color));
     
     typename GraphTraits::vertex_iterator v, vend;
-    for (tie(v, vend) = vertices(G); v != vend; ++v)
+    for (boost::tie(v, vend) = vertices(G); v != vend; ++v)
       color[*v] = V - 1; // which means "not colored"
     
     for (size_type i = 0; i &lt; V; i++) {
@@ -146,7 +142,7 @@ namespace boost {
 
       // mark all the colors of the adjacent vertices
       typename GraphTraits::adjacency_iterator ai, aend;
-      for (tie(ai, aend) = adjacent_vertices(current, G); ai != aend; ++ai)
+      for (boost::tie(ai, aend) = adjacent_vertices(current, G); ai != aend; ++ai)
         mark[color[*ai]] = i; 
 
       // find the smallest color unused by the adjacent vertices
@@ -173,14 +169,14 @@ namespace boost {
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~llee1>Lie-Quan Lee</A>, Univ.of Notre Dame (<A HREF="mailto:llee1@lsc.nd.edu">llee1@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~lums>Andrew Lumsdaine</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:lums@lsc.nd.edu">lums@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
 
 </BODY>

doc/copy_graph.html

@@ -0,0 +1,116 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Copy Graph</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><TT>copy_graph</TT></H1>
+
+<PRE>
+template &lt;class <a href="./VertexListGraph.html">VertexListGraph</a>, class <a href="./MutableGraph.html">MutableGraph</a>&gt; 
+void copy_graph(const VertexListGraph&amp; G, MutableGraph&amp; G_copy,
+    const bgl_named_params&lt;P, T, R&gt;&amp; params = <i>all defaults</i>)
+</PRE>
+
+This function copies all of the vertices and edges from graph
+<tt>G</tt> into <tt>G_copy</tt>. Also, it copies the vertex and edge
+properties, either by using the <tt>vertex_all</tt> and
+<tt>edge_all</tt> property maps, or by user-supplied copy functions.
+
+<H3>Where Defined</H3>
+
+<P>
+<a href="../../../boost/graph/copy.hpp"><TT>boost/graph/copy.hpp</TT></a>
+
+<P>
+
+<H3>Parameters</H3>
+
+IN: <tt>const VertexListGraph&amp; G</tt>
+<blockquote>
+A directed or undirected graph. The graph type must be a model of <a href="./VertexListGraph.html">Vertex List Graph</a>.
+</blockquote>
+
+OUT: <tt>MutableGraph&amp; G_copy</tt>
+<blockquote>
+The resulting copy of the graph.  The graph type must be a model of <a
+href="./MutableGraph.html">Mutable Graph</a>.
+</blockquote>
+
+<h3>Named Parameters</h3>
+
+IN: <tt>vertex_copy(VertexCopier vc)</tt>
+<blockquote>
+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>
+which uses the property tag <tt>vertex_all</tt> to access a property
+map from the graph.
+</blockquote>
+
+IN: <tt>edge_copy(EdgeCopier ec)</tt>
+<blockquote>
+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>
+which uses the property tag <tt>edge_all</tt> to access a property
+map from the graph.
+</blockquote>
+
+IN: <tt>vertex_index_map(VertexIndexMap i_map)</tt>
+<blockquote>
+The vertex index map type must be a model of <a
+href="../../property_map/doc/ReadablePropertyMap.html">Readable Property
+Map</a> and must map the vertex descriptors of <tt>G</tt> to the
+integers in the half-open range <tt>[0,num_vertices(G))</tt>.<br>
+
+<b>Default:</b> <tt>get(vertex_index, G)</tt>.
+Note: if you use this default, make sure your graph has
+an internal <tt>vertex_index</tt> property. For example,
+<tt>adjacency_list</tt> with <tt>VertexList=listS</tt> does
+not have an internal <tt>vertex_index</tt> property.
+</blockquote>
+
+
+UTIL/OUT: <tt>orig_to_copy(Orig2CopyMap c)</tt>
+<blockquote>
+This maps vertices in the original graph to vertices in the copy.
+
+<b>Default:</b> an <a
+  href="../../property_map/doc/iterator_property_map.html">
+  </tt>iterator_property_map</tt></a> created from a
+  <tt>std::vector</tt> of the output graph's vertex descriptor type of size
+  <tt>num_vertices(g)</tt> and using the <tt>i_map</tt> for the index
+  map.
+</blockquote>
+
+<H3>Complexity</H3>
+
+<P>
+The time complexity is <i>O(V + E)</i>.
+
+
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 

doc/cuthill_mckee_ordering.html

@@ -0,0 +1,248 @@
+<HTML>
+
+<!--   Copyright (c) Jeremy Siek 2000
+  
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+
+<Head> 
+<Title>Boost Graph Library: Cuthill-Mckee Ordering</Title>
+</Head>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1>
+<img src="figs/python.gif" alt="(Python)"/>
+<TT>cuthill_mckee_ordering</TT>
+</H1>
+
+
+<P>
+<DIV ALIGN="LEFT">
+<TABLE CELLPADDING=3 border>
+<TR><TH ALIGN="LEFT"><B>Graphs:</B></TH>
+<TD ALIGN="LEFT">undirected</TD>
+</TR>
+<TR><TH ALIGN="LEFT"><B>Properties:</B></TH>
+<TD ALIGN="LEFT">color, degree</TD>
+</TR>
+<TR><TH ALIGN="LEFT"><B>Complexity:</B></TH>
+<TD ALIGN="LEFT">time: <i>O(m log(m)|V|)</i> where <i>m = max { degree(v) | v in V }</i> </TD>
+</TR>
+</TABLE>
+</DIV>
+
+
+<pre>
+  (1)
+  template &lt;class IncidenceGraph, class OutputIterator,
+            class ColorMap, class DegreeMap&gt;
+  OutputIterator
+  cuthill_mckee_ordering(const IncidenceGraph&amp; g,
+                         typename graph_traits&lt;IncidenceGraph&gt;::vertex_descriptor s,
+                         OutputIterator inverse_permutation, 
+                         ColorMap color, DegreeMap degree)
+
+  (2)
+  template &lt;class VertexListGraph, class OutputIterator&gt;
+  OutputIterator
+  cuthill_mckee_ordering(const VertexListGraph&amp; g, OutputIterator inverse_permutation); 
+
+  template &lt;class VertexListGraph, class OutputIterator, class VertexIndexMap&gt;
+  OutputIterator
+  cuthill_mckee_ordering(const VertexListGraph&amp; g, OutputIterator inverse_permutation, 
+                         VertexIndexMap index_map); 
+ 
+  template &lt;class VertexListGraph, class OutputIterator, 
+            class ColorMap, class DegreeMap&gt;
+  OutputIterator
+  cuthill_mckee_ordering(const VertexListGraph&amp; g, OutputIterator inverse_permutation, 
+                         ColorMap color, DegreeMap degree)
+                         
+  (3)
+  template &lt;class IncidenceGraph, class OutputIterator,
+            class ColorMap, class DegreeMap&gt;
+  OutputIterator
+  cuthill_mckee_ordering(const IncidenceGraph&amp; g,
+    			 std::deque&lt; typename
+			 graph_traits&lt;IncidenceGraph&gt;::vertex_descriptor &gt; vertex_queue,
+                         OutputIterator inverse_permutation, 
+                         ColorMap color, DegreeMap degree)
+</pre>
+
+The goal of the Cuthill-Mckee (and reverse Cuthill-Mckee) ordering
+algorithm[<A
+HREF="bibliography.html#george81:__sparse_pos_def">14</A>, <A
+HREF="bibliography.html#cuthill69:reducing_bandwith">43</A>, <a
+href="bibliography.html#liu75:anal_cm_rcm">44</a>, <a
+href="bibliography.html#george71:fem">45</a> ] is to reduce the <a
+href="./bandwidth.html">bandwidth</a> of a graph by reordering the
+indices assigned to each vertex.  The Cuthill-Mckee ordering algorithm
+works by a local minimization of the i-th bandwidths. The vertices are
+basically assigned a breadth-first search order, except that at each
+step, the adjacent vertices are placed in the queue in order of
+increasing degree.
+
+<p>
+Version 1 of the algorithm lets the user choose the ``starting
+vertex'', version 2 finds a good starting vertex using the
+pseudo-peripheral pair heuristic (among each component), while version 3 
+contains the starting nodes for each vertex in the deque.  The choice of the 
+``starting vertex'' can have a significant effect on the quality of the 
+ordering.  For versions 2 and 3, <tt>find_starting_vertex</tt> will be called 
+for each component in the graph, increasing run time significantly.
+</p>
+
+<p>
+The output of the algorithm are the vertices in the new ordering.
+Depending on what kind of output iterator you use, you can get either
+the Cuthill-Mckee ordering or the reverse Cuthill-McKee ordering.  For
+example, if you store the output into a vector using the vector's
+reverse iterator, then you get the reverse Cuthill-McKee ordering.
+</p>
+
+<pre>
+  std::vector&lt;vertex_descriptor&gt; inv_perm(num_vertices(G));
+  cuthill_mckee_ordering(G, inv_perm.rbegin(), ...);
+</pre>
+
+<p>
+Either way, storing the output into a vector gives you the
+permutation from the new ordering to the old ordering.
+</p>
+
+<pre>
+  inv_perm[new_index[u]] == u
+</pre>
+
+<p>
+Often times, it is the opposite permutation that you want, the
+permutation from the old index to the new index. This can easily be
+computed in the following way.
+</p>
+
+<pre>
+  for (size_type i = 0; i != inv_perm.size(); ++i)
+    perm[old_index[inv_perm[i]]] = i;
+</pre>
+
+
+
+<h3>Parameters</h3>
+
+For version 1:
+
+<ul>
+
+<li> <tt>IncidenceGraph&amp; g</tt> &nbsp;(IN) <br> 
+  An undirected graph. The graph's type must be a model of <a
+  href="./IncidenceGraph.html">IncidenceGraph</a>.<br>
+  <b>Python</b>: The parameter is named <tt>graph</tt>.
+
+<li> <tt>vertex_descriptor s</tt> &nbsp(IN) <br>
+  The starting vertex.<br>
+  <b>Python</b>: Unsupported parameter.
+
+<li> <tt>OutputIterator inverse_permutation</tt> &nbsp(OUT) <br> 
+  The new vertex ordering. The vertices are written to the <a
+  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>.
+  
+<li> <tt>ColorMap color_map</tt> &nbsp(WORK) <br>
+  Used internally to keep track of the progress of the algorithm
+  (to avoid visiting the same vertex twice).<br>
+  <b>Python</b>: Unsupported parameter.
+
+<li> <tt>DegreeMap degree_map</tt> &nbsp(IN) <br>
+  This must map vertices to their degree.<br>
+  <b>Python</b>: Unsupported parameter.
+</ul>
+
+
+For version 2:
+
+<ul>
+
+<li> <tt>VertexListGraph&amp; g</tt> &nbsp;(IN) <br> 
+  An undirected graph. The graph's type must be a model of <a
+                                                              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.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>
+  <b>Python</b>: This parameter is unused in Python. The new vertex
+  ordering is returned as a Python <tt>list</tt>.
+
+<li> <tt>ColorMap color_map</tt> &nbsp(WORK) <br>
+  Used internally to keep track of the progress of the algorithm
+  (to avoid visiting the same vertex twice).<br>
+  <b>Python</b>: Unsupported parameter.
+
+<li> <tt>DegreeMap degree_map</tt> &nbsp(IN) <br>
+  This must map vertices to their degree.<br>
+  <b>Python</b>: Unsupported parameter.
+</ul>
+
+
+For version 3:
+
+<ul>
+
+<li> <tt>IncidenceGraph&amp; g</tt> &nbsp;(IN) <br> 
+  An undirected graph. The graph's type must be a model of <a
+  href="./IncidenceGraph.html">IncidenceGraph</a>.<br>
+  <b>Python</b>: The parameter is named <tt>graph</tt>.
+
+<li> <tt> std::deque&lt; typename graph_traits&lt;Graph&gt;::vertex_descriptor &gt; vertex_queue </tt> &nbsp(IN) <br>
+  The deque containing the starting vertices for each component.<br>
+  <b>Python</b>: Unsupported parameter.
+
+<li> <tt>OutputIterator inverse_permutation</tt> &nbsp(OUT) <br> 
+  The new vertex ordering. The vertices are written to the <a
+  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>.
+  
+<li> <tt>ColorMap color_map</tt> &nbsp(WORK) <br>
+  Used internally to keep track of the progress of the algorithm
+  (to avoid visiting the same vertex twice).<br>
+  <b>Python</b>: Unsupported parameter.
+
+<li> <tt>DegreeMap degree_map</tt> &nbsp(IN) <br>
+  This must map vertices to their degree.<br>
+  <b>Python</b>: Unsupported parameter.
+</ul>
+
+
+
+<h3>Example</h3>
+
+See <a
+href="../example/cuthill_mckee_ordering.cpp"><tt>example/cuthill_mckee_ordering.cpp</tt></a>.
+
+<h3>See Also</h3>
+
+<a href="./bandwidth.html">bandwidth</tt></a>,
+and <tt>degree_property_map</tt> in <tt>boost/graph/properties.hpp</tt>.
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 

doc/cycle_canceling.html

@@ -0,0 +1,223 @@
+<HTML>
+<!--
+     Copyright (c) Piotr Wygocki 2013
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Cycle Canceling for  Min Cost Max Flow</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><A NAME="sec:cycle_canceling">
+<TT>cycle_canceling</TT>
+</H1>
+
+<PRE>
+<i>// named parameter version</i>
+template &lt;class <a href="./Graph.html">Graph</a>, class P, class T, class R&gt;
+void cycle_canceling(
+        Graph &amp;g, 
+        const bgl_named_params&lt;P, T, R&gt; &amp; params  = <i>all defaults</i>)
+
+<i>// non-named parameter version</i>
+template &lt;class <a href="./Graph.html">Graph</a>, class Pred, class Distance, class Reversed, class ResidualCapacity, class Weight&gt;
+void cycle_canceling(const Graph &amp; g, Weight weight, Reversed rev, ResidualCapacity residual_capacity, Pred pred, Distance distance) 
+</PRE>
+
+<P>
+The <tt>cycle_canceling()</tt> function calculates the minimum cost flow of a network with given flow. See Section <a
+href="./graph_theory_review.html#sec:network-flow-algorithms">Network
+Flow Algorithms</a> for a description of maximum flow. 
+For given flow values <i> f(u,v)</i>  function minimizes flow cost in such a way, that for each <i>v in V</i> the
+ <i> sum<sub> u in V</sub>  f(v,u) </i> is preserved. Particularly if the input flow was the maximum flow, the function produces min cost max flow.
+  
+
+ The function calculates the flow values <i>f(u,v)</i> for all <i>(u,v)</i> in
+<i>E</i>, which are returned in the form of the residual capacity
+<i>r(u,v) = c(u,v) - f(u,v)</i>. 
+
+<p>
+There are several special requirements on the input graph and property
+map parameters for this algorithm. First, the directed graph
+<i>G=(V,E)</i> that represents the network must be augmented to
+include the reverse edge for every edge in <i>E</i>.  That is, the
+input graph should be <i>G<sub>in</sub> = (V,{E U
+E<sup>T</sup>})</i>. The <tt>ReverseEdgeMap</tt> argument <tt>rev</tt>
+must map each edge in the original graph to its reverse edge, that is
+<i>(u,v) -> (v,u)</i> for all <i>(u,v)</i> in <i>E</i>. 
+The <tt>WeightMap</tt> has to map each edge from <i>E<sup>T</sup></i> to <i>-weight</i> of its reversed edge.
+Note that edges from <i>E</i> can have negative weights. 
+<p>
+If weights in the graph are nonnegative, the 
+<a href="./successive_shortest_path_nonnegative_weights.html"><tt>successive_shortest_path_nonnegative_weights()</tt></a> 
+might be better choice for min cost max flow.
+
+<p>
+The algorithm is described in <a
+href="./bibliography.html#ahuja93:_network_flows">Network Flows</a>.
+
+<p>
+In each round algorithm augments the negative cycle (in terms of weight) in the residual graph.
+If there is no negative cycle in the network, the cost is optimized.
+
+<p>
+Note that, although we mention capacity in the problem description, the actual algorithm doesn't have to now it.
+
+<p> 
+In order to find the cost of the result flow use:
+<a href="./find_flow_cost.html"><tt>find_flow_cost()</tt></a>.
+
+
+<H3>Where Defined</H3>
+
+<P>
+<a href="../../../boost/graph/successive_shortest_path_nonnegative_weights.hpp"><TT>boost/graph/successive_shortest_path_nonnegative_weights.hpp</TT></a>
+
+<P>
+
+<h3>Parameters</h3>
+
+IN: <tt>Graph&amp; g</tt>
+<blockquote>
+  A directed graph. The
+  graph's type must be a model of <a
+  href="./VertexListGraph.html">VertexListGraph</a> and <a href="./IncidenceGraph.html">IncidenceGraph</a> For each edge
+  <i>(u,v)</i> in the graph, the reverse edge <i>(v,u)</i> must also
+  be in the graph.
+</blockquote>
+  
+<h3>Named Parameters</h3>
+
+  
+IN/OUT: <tt>residual_capacity_map(ResidualCapacityEdgeMap res)</tt>
+<blockquote>
+  This maps edges to their residual capacity. The type must be a model
+  of a mutable <a
+  href="../../property_map/doc/LvaluePropertyMap.html">Lvalue Property
+  Map</a>. The key type of the map must be the graph's edge descriptor
+  type.<br>
+  <b>Default:</b> <tt>get(edge_residual_capacity, g)</tt>
+</blockquote>
+
+IN: <tt>reverse_edge_map(ReverseEdgeMap rev)</tt>
+<blockquote>
+  An edge property map that maps every edge <i>(u,v)</i> in the graph
+  to the reverse edge <i>(v,u)</i>. The map must be a model of
+  constant <a href="../../property_map/doc/LvaluePropertyMap.html">Lvalue
+  Property Map</a>. The key type of the map must be the graph's edge
+  descriptor type.<br>
+  <b>Default:</b> <tt>get(edge_reverse, g)</tt>
+</blockquote>
+
+IN: <tt>weight_map(WeightMap w)</tt>
+<blockquote>
+  The weight (also know as ``length'' or ``cost'') 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>.  The key type for this property map must be the edge
+  descriptor of the graph.  The value type for the weight map must be
+  <i>Addable</i> with the distance map's value type. <br>
+  <b>Default:</b> <tt>get(edge_weight, g)</tt><br>
+</blockquote>
+
+UTIL: <tt>predecessor_map(PredEdgeMap pred)</tt>
+<blockquote>
+  Use by the algorithm to store augmenting paths. The map must be a
+  model of mutable <a
+  href="../../property_map/doc/LvaluePropertyMap.html">Lvalue Property Map</a>.
+  The key type must be the graph's vertex descriptor type and the
+  value type must be the graph's edge descriptor type.<br>
+
+  <b>Default:</b> an <a
+  href="../../property_map/doc/iterator_property_map.html">
+  <tt>iterator_property_map</tt></a> created from a <tt>std::vector</tt>
+  of edge descriptors of size <tt>num_vertices(g)</tt> and
+  using the <tt>i_map</tt> for the index map.
+</blockquote>
+
+UTIL: <tt>distance_map(DistanceMap d_map)</tt> 
+<blockquote>
+  The shortest path weight from the source vertex <tt>s</tt> to each
+  vertex in the graph <tt>g</tt> is recorded in this property map. The
+  shortest path weight is the sum of the edge weights along the
+  shortest path.  The type <tt>DistanceMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a>. The vertex descriptor type of the graph needs to
+  be usable as the key type of the distance map. 
+
+  <b>Default:</b> <a
+  href="../../property_map/doc/iterator_property_map.html">
+  <tt>iterator_property_map</tt></a> created from a
+  <tt>std::vector</tt> of the <tt>WeightMap</tt>'s value type of size
+  <tt>num_vertices(g)</tt> and using the <tt>i_map</tt> for the index
+  map.<br>
+
+</blockquote>
+
+IN: <tt>vertex_index_map(VertexIndexMap i_map)</tt>
+<blockquote>
+  Maps each vertex of the graph to a unique integer in the range
+  <tt>[0, num_vertices(g))</tt>. This property map is only needed
+  if the default for the distance or predecessor map is used.
+  The vertex index map must be a model of <a
+  href="../../property_map/doc/ReadablePropertyMap.html">Readable Property
+  Map</a>. The key type of the map must be the graph's vertex
+  descriptor type.<br>
+  <b>Default:</b> <tt>get(vertex_index, g)</tt>
+    Note: if you use this default, make sure your graph has
+    an internal <tt>vertex_index</tt> property. For example,
+    <tt>adjacency_list</tt> with <tt>VertexList=listS</tt> does
+    not have an internal <tt>vertex_index</tt> property.
+</blockquote>
+
+<h3>Complexity</h3>
+In the integer capacity and weight case, if <i>C</i> is the initial cost of the flow, then the complexity is <i> O(C * |V| * |E|)</i>, 
+where <i>O(|E|* |V|)</i> is the complexity of the bellman ford shortest paths algorithm and <i>C</i> is upper bound on number of iteration. 
+In many real world cases number of iterations is much smaller than <i>C</i>.
+
+
+<h3>Example</h3>
+
+The program in <a
+href="../example/cycle_canceling_example.cpp"><tt>example/cycle_canceling_example.cpp</tt></a>.
+
+
+<h3>See Also</h3>
+
+<a href="./successive_shortest_path_nonnegative_weights.html"><tt>successive_shortest_path_nonnegative_weights()</tt></a><br>
+<a href="./find_flow_cost.html"><tt>find_flow_cost()</tt></a>.
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2013</TD><TD>
+Piotr Wygocki, University of Warsaw (<A HREF="mailto:wygos@mimuw.edu.pl">wygos at mimuw.edu.pl</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 
+<!--  LocalWords:  HTML Siek Edmonds BGCOLOR ffffff ee VLINK ALINK ff IMG SRC
+ -->
+<!--  LocalWords:  gif ALT BR sec edmonds karp TT DIV CELLPADDING TR TD PRE lt
+ -->
+<!--  LocalWords:  typename VertexListGraph CapacityEdgeMap ReverseEdgeMap gt
+ -->
+<!--  LocalWords:  ResidualCapacityEdgeMap VertexIndexMap src rev ColorMap pred
+ -->
+<!--  LocalWords:  PredEdgeMap tt href html hpp ul li nbsp br LvaluePropertyMap
+ -->
+<!--  LocalWords:  num ColorValue DIMACS cpp pre config iostream dimacs int std
+ -->
+<!--  LocalWords:  namespace vecS directedS cout endl iter ei HR valign nowrap
+ -->
+<!--  LocalWords:  jeremy siek htm Univ mailto jsiek lsc edu
+p -->
+

doc/dag_shortest_paths.html

@@ -0,0 +1,326 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Directed Acyclic Graph Shortest Paths</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><A NAME="sec:dag_shortest_paths"></A>
+<img src="figs/python.gif" alt="(Python)"/>
+<TT>dag_shortest_paths</TT>
+</H1>
+
+
+<P>
+<PRE>
+<i>// named paramter version</i>
+template &lt;class VertexListGraph, class Param, class Tag, class Rest&gt;
+void dag_shortest_paths(const VertexListGraph&amp; g,
+   typename graph_traits&lt;VertexListGraph&gt;::vertex_descriptor s,
+   const bgl_named_params&lt;Param,Tag,Rest&gt;&amp; params)
+
+<i>// non-named parameter version</i>
+template &lt;class VertexListGraph, class DijkstraVisitor, 
+	  class DistanceMap, class WeightMap, class ColorMap, 
+	  class PredecessorMap,
+	  class Compare, class Combine, 
+	  class DistInf, class DistZero&gt;
+void dag_shortest_paths(const VertexListGraph&amp; g,
+   typename graph_traits&lt;VertexListGraph&gt;::vertex_descriptor s, 
+   DistanceMap distance, WeightMap weight, ColorMap color,
+   PredecessorMap pred, DijkstraVisitor vis, 
+   Compare compare, Combine combine, DistInf inf, DistZero zero)
+</PRE>
+
+<P>
+This algorithm&nbsp;[<A HREF="bibliography.html#clr90">8</A>] solves
+the single-source shortest-paths problem on a weighted, directed 
+acyclic graph (DAG). This algorithm is more efficient for DAG's
+than either the Dijkstra or Bellman-Ford algorithm.
+Use breadth-first search instead of this algorithm
+when all edge weights are equal to one.  For the definition of the
+shortest-path problem see Section <A
+HREF="graph_theory_review.html#sec:shortest-paths-algorithms">Shortest-Paths
+Algorithms</A> for some background to the shortest-path problem.
+</P>
+
+<P>
+There are two main options for obtaining output from the
+<tt>dag_shortest_paths()</tt> function. If you provide a
+distance property map through the <tt>distance_map()</tt> parameter
+then the shortest distance from the source vertex to every other
+vertex in the graph will be recorded in the distance map. Also you can
+record the shortest paths tree in a predecessor map: for each vertex
+<i>u in V</i>, <i>p[u]</i> will be the predecessor of <i>u</i> in
+the shortest paths tree (unless <i>p[u] = u</i>, in which case <i>u</i> is
+either the source or a vertex unreachable from the source).  In
+addition to these two options, the user can provide there own
+custom-made visitor that can takes actions during any of the
+algorithm's event points.</P>
+
+<h3>Where Defined</h3>
+
+<a href="../../../boost/graph/dag_shortest_paths.hpp"><tt>boost/graph/dag_shortest_paths.hpp</tt></a>
+
+<h3>Parameters</h3>
+
+IN: <tt>const VertexListGraph&amp; g</tt> 
+<blockquote>
+  The graph object on which the algorithm will be applied.
+  The type <tt>VertexListGraph</tt> must be a model of \concept{VertexListGraph}.<br>
+
+  <b>Python</b>: The parameter is named <tt>graph</tt>.
+</blockquote>
+
+IN: <tt>vertex_descriptor s</tt> 
+<blockquote>
+  The source vertex. All distance will be calculated from this vertex,
+  and the shortest paths tree will be rooted at this vertex.<br>
+
+  <b>Python</b>: The parameter is named <tt>root_vertex</tt>.
+</blockquote>
+
+<h3>Named Parameters</h3>
+
+IN: <tt>weight_map(WeightMap w_map)</tt>   
+<blockquote>
+  The weight or ``length'' of each edge in the graph.
+  The type <tt>WeightMap</tt> must be a model of
+  <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a>. The edge descriptor type of
+  the graph needs to be usable as the key type for the weight
+  map. The value type for the map must be
+  <i>Addable</i> with the value type of the distance map.<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>
+  <b>Python default</b>: <tt>graph.get_edge_double_map("weight")</tt>
+
+</blockquote>
+
+IN: <tt>vertex_index_map(VertexIndexMap i_map)</tt> 
+<blockquote>
+  This maps each vertex to an integer in the range <tt>[0,
+    num_vertices(g))</tt>. This is necessary for efficient updates of the
+  heap data structure when an edge is relaxed.  The type
+  <tt>VertexIndexMap</tt> must be a model of
+  <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a>. The value type of the map must be an
+  integer type. The vertex descriptor type of the graph needs to be
+  usable as the key type of the map.<br>
+  <b>Default:</b> <tt>get(vertex_index, g)</tt>.
+    Note: if you use this default, make sure your graph has
+    an internal <tt>vertex_index</tt> property. For example,
+    <tt>adjacency_list</tt> with <tt>VertexList=listS</tt> does
+    not have an internal <tt>vertex_index</tt> property.<br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+OUT: <tt>predecessor_map(PredecessorMap p_map)</tt> 
+<blockquote>
+  The predecessor map records the edges in the minimum spanning
+  tree. Upon completion of the algorithm, the edges <i>(p[u],u)</i>
+  for all <i>u in V</i> are in the minimum spanning tree. If <i>p[u] =
+  u</i> then <i>u</i> is either the source vertex or a vertex that is
+  not reachable from the source.  The <tt>PredecessorMap</tt> type
+  must be a <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a> which key and vertex types the same as the vertex
+  descriptor type of the graph.<br>
+  <b>Default:</b> <tt>dummy_property_map</tt><br>
+  <b>Python</b>: Must be a <tt>vertex_vertex_map</tt> for the graph.<br>
+</blockquote>
+
+UTIL/OUT: <tt>distance_map(DistanceMap d_map)</tt> 
+<blockquote>
+  The shortest path weight from the source vertex <tt>s</tt> to each
+  vertex in the graph <tt>g</tt> is recorded in this property map. The
+  shortest path weight is the sum of the edge weights along the
+  shortest path.  The type <tt>DistanceMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a>. The vertex descriptor type of the graph needs to
+  be usable as the key type of the distance map. 
+
+  The value type of the distance map is the element type of a <a
+  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.boost.org/sgi/stl/StrictWeakOrdering.html">
+  StrictWeakOrdering</a> provided by the <tt>compare</tt> function
+  object.<br>
+  <b>Default:</b> <a
+  href="../../property_map/doc/iterator_property_map.html">
+  <tt>iterator_property_map</tt></a> created from a
+  <tt>std::vector</tt> of the <tt>WeightMap</tt>'s value type of size
+  <tt>num_vertices(g)</tt> and using the <tt>i_map</tt> for the index
+  map.<br>
+
+  <b>Python</b>: Must be a <tt>vertex_double_map</tt> for the graph.
+</blockquote>
+
+IN: <tt>distance_compare(CompareFunction cmp)</tt> 
+<blockquote>
+  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.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>
+
+  <b>Default:</b>
+  <tt>std::less&lt;D&gt;</tt> with <tt>D=typename
+  property_traits&lt;DistanceMap&gt;::value_type</tt><br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+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.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>std::plus&lt;D&gt;</tt> with
+   <tt>D=typename property_traits&lt;DistanceMap&gt;::value_type</tt><br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+IN: <tt>distance_inf(D inf)</tt> 
+<blockquote>
+  The <tt>inf</tt> object must be the greatest value of any <tt>D</tt> object.
+  That is, <tt>compare(d, inf) == true</tt> for any <tt>d != inf</tt>.
+  The type <tt>D</tt> is the value type of the <tt>DistanceMap</tt>.<br>
+  <b>Default:</b> <tt>std::numeric_limits&lt;D&gt;::max()</tt><br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+IN: <tt>distance_zero(D zero)</tt> 
+<blockquote>
+  The <tt>zero</tt> value must be the identity element for the
+  <a href="./Monoid.html">Monoid</a> formed by the distance values
+  and the <tt>combine</tt> function object.
+  The type \code{D} is the value type of the \code{DistanceMap}
+  <b>Default:</b> <tt>D()</tt><br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+UTIL/OUT: <tt>color_map(ColorMap c_map)</tt> 
+<blockquote>
+  This is used during the execution of the algorithm to mark the
+  vertices. The vertices start out white and become gray when they are
+  inserted in the queue. They then turn black when they are removed
+  from the queue. At the end of the algorithm, vertices reachable from
+  the source vertex will have been colored black. All other vertices
+  will still be white. The type <tt>ColorMap</tt> must be a model of
+  <a href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a>. A vertex descriptor must be usable as the key type
+  of the map, and the value type of the map must be a model of
+  <a href="./ColorValue.html">Color Value</a>.<br>
+  <b>Default:</b> an <a
+  href="../../property_map/doc/iterator_property_map.html">
+  <tt>iterator_property_map</tt></a> created from a <tt>std::vector</tt>
+  of <tt>default_color_type</tt> of size <tt>num_vertices(g)</tt> and
+  using the <tt>i_map</tt> for the index map.<br>
+
+  <b>Python</b>: The color map must be a <tt>vertex_color_map</tt> for
+  the graph.
+
+</blockquote>
+  
+OUT: <tt>visitor(DijkstraVisitor v)</tt>  
+<blockquote>
+  Use this to specify actions that you would like to happen
+  during certain event points within the algorithm.
+  The type <tt>DijkstraVisitor</tt> must be a model of the
+  <a href="./DijkstraVisitor.html">Dijkstra Visitor</a> concept. 
+ The visitor object is passed by value <a
+  href="#1">[1]</a>.<br>
+  <b>Default:</b> <tt>dijkstra_visitor&lt;null_visitor&gt;</tt><br>
+
+  <b>Python</b>: The parameter should be an object that derives from
+  the <a
+  href="DijkstraVisitor.html#python"><tt>DijkstraVisitor</tt></a> type
+  of the graph.
+</blockquote>
+
+
+<H3>Complexity</H3>
+
+<P>
+The time complexity is <i>O(V + E)</i>.
+
+<h3>Visitor Event Points</h3>
+
+<ul>
+<li><b><tt>vis.initialize_vertex(u, g)</tt></b>
+  is invoked on each vertex in the graph before the start of the
+  algorithm.
+<li><b><tt>vis.examine_vertex(u, g)</tt></b>
+  is invoked on a vertex as it is added to set <i>S</i>. 
+  At this point we know that <i>(p[u],u)</i>
+  is a shortest-paths tree edge so 
+  <i>d[u] = delta(s,u) = d[p[u]] + w(p[u],u)</i>. Also, the distances 
+  of the examined vertices is monotonically increasing
+  <i>d[u<sub>1</sub>] <= d[u<sub>2</sub>] <= d[u<sub>n</sub>]</i>. 
+<li><b><tt>vis.examine_edge(e, g)</tt></b>
+  is invoked on each out-edge of a vertex immediately after it has
+  been added to set <i>S</i>. 
+<li><b><tt>vis.edge_relaxed(e, g)</tt></b>
+  is invoked on edge <i>(u,v)</i> if <i>d[u] + w(u,v) < d[v]</i>.
+  The edge <i>(u,v)</i> that participated in the last
+  relaxation for vertex <i>v</i> is an edge in the shortest paths tree. 
+<li><b><tt>vis.discover_vertex(v, g)</tt></b>
+  is invoked on vertex <i>v</i> when the edge 
+  <i>(u,v)</i> is examined and <i>v</i> is WHITE. Since
+  a vertex is colored GRAY when it is discovered,
+  each reacable vertex is discovered exactly once.
+<li><b><tt>vis.edge_not_relaxed(e, g)</tt></b>
+  is invoked if the edge is not relaxed (see above).
+<li><b><tt>vis.finish_vertex(u, g)</tt></b>
+   is invoked on a vertex after all of its out edges have
+  been examined.
+</ul>
+
+<H3>Example</H3>
+
+<P>
+See <a href="../example/dag_shortest_paths.cpp">
+<TT>example/dag_shortest_paths.cpp</TT></a> for an example of using this
+algorithm.
+
+<H3>Notes</H3>
+
+<p><a name="1">[1]</a> 
+  Since the visitor parameter is passed by value, if your visitor
+  contains state then any changes to the state during the algorithm
+  will be made to a copy of the visitor object, not the visitor object
+  passed in. Therefore you may want the visitor to hold this state by
+  pointer or reference.
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 
+

doc/depth_first_search.html

@@ -0,0 +1,320 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Depth-First Search</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><A NAME="sec:depth-first-search"></A><img src="figs/python.gif" alt="(Python)"/>
+<TT>depth_first_search</TT>
+</H1>
+
+<P>
+<PRE>
+<i>// named parameter version</i>
+template &lt;class Graph, class class P, class T, class R&gt;
+void depth_first_search(Graph&amp; G,
+  const bgl_named_params&lt;P, T, R&gt;&amp; params);
+
+<i>// non-named parameter version</i>
+template &lt;class Graph, class <a href="DFSVisitor.html">DFSVisitor</a>, class ColorMap&gt;
+void depth_first_search(const Graph&amp; g, DFSVisitor vis, ColorMap color)
+
+template &lt;class Graph, class <a href="DFSVisitor.html">DFSVisitor</a>, class ColorMap&gt;
+void depth_first_search(const Graph&amp; g, DFSVisitor vis, ColorMap color, 
+                        typename graph_traits&lt;Graph&gt;::vertex_descriptor start)
+
+</PRE>
+
+<p>
+The <tt>depth_first_search()</tt> function performs a depth-first
+traversal of the vertices in a directed graph.  When
+possible, a depth-first traversal chooses a vertex adjacent to the
+current vertex to visit next. If all adjacent vertices have already
+been discovered, or there are no adjacent vertices, then the algorithm
+backtracks to the last vertex that had undiscovered neighbors. Once
+all reachable vertices have been visited, the algorithm selects from
+any remaining undiscovered vertices and continues the traversal. The
+algorithm finishes when all vertices have been visited. Depth-first
+search is useful for categorizing edges in a graph, and for imposing
+an ordering on the vertices. Section <a
+href="./graph_theory_review.html#sec:dfs-algorithm">Depth-First
+Search</a> describes the various properties of DFS and walks through
+an example.
+</p>
+
+<p>
+Similar to BFS, color markers are used to keep track of which vertices
+have been discovered. White marks vertices that have yet to be
+discovered, gray marks a vertex that is discovered but still has
+vertices adjacent to it that are undiscovered. A black vertex is
+discovered vertex that is not adjacent to any white vertices.
+<p>
+
+<p>
+The <tt>depth_first_search()</tt> function invokes user-defined
+actions at certain event-points within the algorithm. This provides a
+mechanism for adapting the generic DFS algorithm to the many
+situations in which it can be used.  In the pseudo-code below, the
+event points for DFS are the labels on
+the right. The user-defined actions must be provided in the form of a
+visitor object, that is, an object whose type meets the requirements
+for a <a href="./DFSVisitor.html">DFS Visitor</a>. In the pseudo-code
+we show the algorithm computing predecessors <i>p</i>, discover time
+<i>d</i> and finish time <i>t</i>.  By default, the
+<tt>depth_first_search()</tt> function does not compute these
+properties, however there are pre-defined visitors such as <a
+href="./predecessor_recorder.html"><tt>predecessor_recorder</tt></a>
+and <a href="./time_stamper.html"><tt>time_stamper</tt></a> that can
+be used to do this.
+</p>
+
+<table>
+<tr>
+<td valign="top">
+<pre>
+DFS(<i>G</i>)
+  <b>for</b> each vertex <i>u in V</i> 
+    <i>color[u] :=</i> WHITE
+    <i>p[u] = u</i> 
+  <b>end for</b>
+  <i>time := 0</i>
+  <b>if</b> there is a starting vertex <i>s</i>
+    <b>call</b> DFS-VISIT(<i>G</i>, <i>s</i>)
+  <b>for</b> each vertex <i>u in V</i> 
+    <b>if</b> <i>color[u] =</i> WHITE
+      <b>call</b> DFS-VISIT(<i>G</i>, <i>u</i>)
+  <b>end for</b>
+  return (<i>p</i>,<i>d_time</i>,<i>f_time</i>) <br>
+DFS-VISIT(<i>G</i>, <i>u</i>) 
+  <i>color[u] :=</i> GRAY
+  <i>d_time[u] := time := time + 1</i> 
+  <b>for</b> each <i>v in Adj[u]</i> 
+    <b>if</b> (<i>color[v] =</i> WHITE)
+      <i>p[v] = u</i> 
+      <b>call</b> DFS-VISIT(<i>G</i>, <i>v</i>)
+    <b>else if</b> (<i>color[v] =</i> GRAY) 
+      <i>...</i>
+    <b>else if</b> (<i>color[v] =</i> BLACK) 
+      <i>...</i>
+    <i>...</i>
+  <b>end for</b>
+  <i>color[u] :=</i> BLACK
+  <i>f_time[u] := time := time + 1</i> 
+<pre>
+</td>
+<td valign="top">
+<pre>
+-
+-
+initialize vertex <i>u</i>
+-
+-
+-
+-
+start vertex <i>s</i>
+-
+-
+start vertex <i>u</i>
+-
+-
+-
+-
+discover vertex <i>u</i>
+-
+examine edge <i>(u,v)</i>
+-
+<i>(u,v)</i> is a tree edge
+-
+-
+<i>(u,v)</i> is a back edge
+-
+<i>(u,v)</i> is a cross or forward edge
+-
+finish edge <i>(u,v)</i>
+-
+finish vertex <i>u</i>
+-
+</pre>
+</td>
+</tr>
+</table>
+
+
+
+<H3>Where Defined</H3>
+
+<P>
+<a href="../../../boost/graph/depth_first_search.hpp"><TT>boost/graph/depth_first_search.hpp</TT></a>
+
+<h3>Parameters</h3>
+
+IN: <tt>Graph&amp; g</tt>
+<blockquote>
+  A directed graph. The graph type must
+  be a model of <a href="./IncidenceGraph.html">Incidence Graph</a>
+  and <a href="./VertexListGraph.html">Vertex List Graph</a>.<br>
+
+  <b>Python</b>: The parameter is named <tt>graph</tt>.
+</blockquote>
+
+
+<h3>Named Parameters</h3>
+
+IN: <tt>visitor(DFSVisitor vis)</tt>
+<blockquote>
+  A visitor object that is invoked inside the algorithm at the
+  event-points specified by the <a href="./DFSVisitor.html">DFS
+  Visitor</a> concept. The visitor object is passed by value <a
+  href="#1">[1]</a>. <br> <b>Default:</b>
+  <tt>dfs_visitor&lt;null_visitor&gt;</tt><br>
+
+  <b>Python</b>: The parameter should be an object that derives from
+  the <a href="DFSVisitor.html#python"><tt>DFSVisitor</tt></a> type of
+  the graph.
+</blockquote>
+
+UTIL/OUT: <tt>color_map(ColorMap color)</tt>
+<blockquote>
+  This is used by the algorithm to keep track of its progress through
+  the graph. The type <tt>ColorMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a> and its key type must be the graph's vertex
+  descriptor type and the value type of the color map must model
+  <a href="./ColorValue.html">ColorValue</a>.<br>
+  <b>Default:</b> an <a
+  href="../../property_map/doc/iterator_property_map.html">
+  </tt>iterator_property_map</tt></a> created from a
+  <tt>std::vector</tt> of <tt>default_color_type</tt> of size
+  <tt>num_vertices(g)</tt> and using the <tt>i_map</tt> for the index
+  map.<br>
+
+   <b>Python</b>: The color map must be a <tt>vertex_color_map</tt> for
+  the graph.
+</blockquote>
+
+IN: <tt>root_vertex(typename
+graph_traits&lt;VertexListGraph&gt;::vertex_descriptor start)</tt>
+<blockquote>
+  This specifies the vertex that the depth-first search should
+  originate from. The type is the type of a vertex descriptor for the
+  given graph.<br>
+  <b>Default:</b> <tt>*vertices(g).first</tt><br>
+</blockquote>
+
+IN: <tt>vertex_index_map(VertexIndexMap i_map)</tt>
+<blockquote>
+  This maps each vertex to an integer in the range <tt>[0,
+  num_vertices(g))</tt>. This parameter is only necessary when the
+  default color property map is used. The type <tt>VertexIndexMap</tt>
+  must be a model of <a
+  href="../../property_map/doc/ReadablePropertyMap.html">Readable Property
+  Map</a>. The value type of the map must be an integer type. The
+  vertex descriptor type of the graph needs to be usable as the key
+  type of the map.<br>
+
+  <b>Default:</b> <tt>get(vertex_index, g)</tt>.
+    Note: if you use this default, make sure your graph has
+    an internal <tt>vertex_index</tt> property. For example,
+    <tt>adjacency_list</tt> with <tt>VertexList=listS</tt> does
+    not have an internal <tt>vertex_index</tt> property.<br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+<P>
+
+<H3><A NAME="SECTION001340300000000000000">
+Complexity</A>
+</H3>
+
+<P>
+The time complexity is <i>O(E + V)</i>.
+
+<P>
+
+<h3>Visitor Event Points</h3>
+
+<ul>
+
+<li><b><tt>vis.initialize_vertex(s, g)</tt></b> is invoked on every
+  vertex of the graph before the start of the graph search.
+
+<li><b><tt>vis.start_vertex(s, g)</tt></b> is invoked on the source
+  vertex once before the start of the search.
+  
+<li><b><tt>vis.discover_vertex(u, g)</tt></b> is invoked when a vertex
+  is encountered for the first time.
+  
+<li><b><tt>vis.examine_edge(e, g)</tt></b> is invoked on every out-edge
+  of each vertex after it is discovered.
+
+<li><b><tt>vis.tree_edge(e, g)</tt></b> is invoked on each edge as it
+  becomes a member of the edges that form the search tree. If you
+  wish to record predecessors, do so at this event point.
+  
+<li><b><tt>vis.back_edge(e, g)</tt></b> is invoked on the back edges in
+  the graph.
+  
+<li><b><tt>vis.forward_or_cross_edge(e, g)</tt></b> is invoked on
+  forward or cross edges in the graph. In an undirected graph this
+  method is never called.
+
+<li><b><tt>vis.finish_edge(e, g)</tt></b> is invoked on the non-tree edges in 
+  the graph as well as on each tree edge after its target vertex is finished. 
+  
+<li><b><tt>vis.finish_vertex(u, g)</tt></b> is invoked on a vertex after
+  all of its out edges have been added to the search tree and all of
+  the adjacent vertices have been discovered (but before their
+  out-edges have been examined).
+
+</ul>
+
+
+<H3>Example</H3>
+
+<P>
+The example in <a href="../example/dfs-example.cpp">
+<TT>examples/dfs-example.cpp</TT></a> shows DFS applied to the graph in
+<A HREF="./graph_theory_review.html#fig:dfs-example">Figure 1</A>.
+
+<h3>See Also</h3>
+
+<a href="./depth_first_visit.html"><tt>depth_first_visit</tt></a>
+<a href="./undirected_dfs.html"><tt>undirected_dfs</tt></a>
+
+<h3>Notes</h3>
+
+<p><a name="1">[1]</a> 
+  Since the visitor parameter is passed by value, if your visitor
+  contains state then any changes to the state during the algorithm
+  will be made to a copy of the visitor object, not the visitor object
+  passed in. Therefore you may want the visitor to hold this state by
+  pointer or reference.
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
+
+</BODY>
+</HTML> 

doc/depth_first_visit.html

@@ -0,0 +1,144 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Depth-First Visit</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H2><A NAME="sec:dfs"></A>
+<img src="figs/python.gif" alt="(Python)"/>
+<TT>depth_first_visit</TT>
+</H2>
+
+
+<P>
+<PRE>
+template &lt;class <a href="./IncidenceGraph.html">IncidenceGraph</a>, class <a href="./DFSVisitor.html">DFSVisitor</a>, class ColorMap&gt;
+void depth_first_visit(IncidenceGraph& g,
+  typename graph_traits&lt;IncidenceGraph&gt;::vertex_descriptor s, 
+  DFSVisitor&amp; vis, ColorMap color)
+
+template &lt;class <a href="./IncidenceGraph.html">IncidenceGraph</a>, class <a href="./DFSVisitor.html">DFSVisitor</a>, class ColorMap, 
+          class TerminatorFunc&gt;
+void depth_first_visit(IncidenceGraph& g,
+  typename graph_traits&lt;IncidenceGraph&gt;::vertex_descriptor s, 
+  DFSVisitor&amp; vis, ColorMap color, TerminatorFunc func = TerminatorFunc())
+</PRE>
+
+<P>
+This function visits all of the vertices in the same connected
+component as the source vertex <tt>s</tt>, using the <a
+href="./graph_theory_review.html#sec:dfs-algorithm">depth-first
+pattern</a>. The main purpose of the function is for the
+implementation of <TT>depth_first_search()</TT> though sometimes it is
+useful on its own. 
+
+<p>
+The <tt>DFSVisitor</tt> supplied by the user determines what
+actions are taken at each event-point within the algorithm.
+
+<p>
+The <tt>ColorMap</tt> is used by the algorithm to keep track
+of which vertices have been visited.
+
+<p>The second variant can be used, for example, to find all marked vertices
+reachable from a start vertex by a path which does not contain any another
+marked vertices.
+
+
+<P>
+
+<h3>Where Defined:</h3>
+
+<a href="../../../boost/graph/depth_first_search.hpp"><TT>boost/graph/depth_first_search.hpp</TT></a>
+
+
+<h3>Parameters</h3>
+
+IN <tt>IncidenceGraph&amp; g</tt>
+<blockquote>
+A directed or undirected graph. The graph's type must be a model of
+<a href="./IncidenceGraph.html">Incidence Graph</a>.<br>
+
+<b>Python</b>: The parameter is named <tt>graph</tt>.
+</blockquote>
+
+IN: <tt>vertex_descriptor s</tt>
+<blockquote>
+  The source vertex from which to start the search.<br>
+
+  <b>Python</b>: The parameter is named <tt>root_vertex</tt>.
+</blockquote>
+
+IN: <tt>DFSVisitor visitor</tt>
+<blockquote>
+  A visitor object that is invoked inside the algorithm at the
+  event-points specified by the <a href="./DFSVisitor.html">DFS
+  Visitor</a> concept. The visitor object is passed by value <a
+  href="#1">[1]</a>.<br>
+
+  <b>Python</b>: The parameter should be an object that derives from
+  the <a href="DFSVisitor.html#python"><tt>DFSVisitor</tt></a> type of
+  the graph.
+</blockquote>
+
+UTIL: <tt>ColorMap color</tt>
+<blockquote>
+  This is used by the algorithm to keep track of its progress through
+  the graph. The type <tt>ColorMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a> and its key type must be the graph's vertex
+  descriptor type and the value type of the color map map must model
+  <a href="./ColorValue.html">Color Value</a>.<br>
+
+  <b>Python</b>: The color map must be a <tt>vertex_color_map</tt> for
+  the graph.
+</blockquote>
+
+IN: <tt>TerminatorFunc func</tt>
+<blockquote>
+A function object callable with two parameters - the descriptor of
+vertex and the graph instance - and returning bool. The call is made
+immediately after call to 'discover_vertex' visitor
+event. If <tt>true</tt> is returned, the out edges of the vertex are
+not examined, as if they don't exist.<br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+<P>
+
+<h3>Complexity</h3>
+
+Time complexity is <i>O(E)</i>.
+
+
+<h3>Notes</h3>
+
+<p><a name="1">[1]</a> 
+  Since the visitor parameter is passed by value, if your visitor
+  contains state then any changes to the state during the algorithm
+  will be made to a copy of the visitor object, not the visitor object
+  passed in. Therefore you may want the visitor to hold this state by
+  pointer or reference.
+
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 

doc/dfs_visitor.html

@@ -1,20 +1,16 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  We make no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>Boost Graph Library: dfs_visitor</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -26,7 +22,7 @@ dfs_visitor&lt;EventVisitorList&gt;
 </H1>
 
 This class is an adapter that converts a list of <a
-href="./EventVisitor.html">EventVisitor</a>'s (constructed using
+href="./EventVisitor.html">EventVisitor</a>s (constructed using
 <tt>std::pair</tt>) into a <a href="./DFSVisitor.html">DFSVisitor</a>.
 
 
@@ -67,7 +63,7 @@ with <tt>std::pair</tt>.
 This class implements all of the member functions required by <a
 href="./DFSVisitor.html">DFSVisitor</a>. In each function the
 appropriate event is dispatched to the <a
-href="./EventVisitor.html">EventVisitor</a>'s in the EventVisitorList.
+href="./EventVisitor.html">EventVisitor</a> in the EventVisitorList.
 
 <h3>Non-Member Functions</h3>
 
@@ -101,14 +97,14 @@ and <a href="./property_writer.html"><tt>property_writer</tt></a>.
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~llee1>Lie-Quan Lee</A>, Univ.of Notre Dame (<A HREF="mailto:llee1@lsc.nd.edu">llee1@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~lums>Andrew Lumsdaine</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:lums@lsc.nd.edu">lums@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
 
 </BODY>

doc/dijkstra_shortest_paths.html

@@ -0,0 +1,464 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Dijkstra's Shortest Paths</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><A NAME="sec:dijkstra"></A><img src="figs/python.gif" alt="(Python)"/>
+<TT>dijkstra_shortest_paths</TT>
+</H1>
+
+<P>
+<PRE>
+<i>// named parameter version</i>
+template &lt;typename Graph, typename P, typename T, typename R&gt;
+void
+dijkstra_shortest_paths(Graph&amp; g,
+  typename graph_traits&lt;Graph&gt;::vertex_descriptor s,
+  const bgl_named_params&lt;P, T, R&gt;&amp; params);
+
+<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.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,
+   typename graph_traits&lt;Graph&gt;::vertex_descriptor s, 
+   PredecessorMap predecessor, DistanceMap distance, WeightMap weight, 
+   VertexIndexMap index_map,
+   CompareFunction compare, CombineFunction combine, DistInf inf, DistZero zero,
+   DijkstraVisitor vis, ColorMap color = <i>default</i>)
+
+<i>// version that does not initialize the property maps (except for the default color map)</i>
+template &lt;class Graph, class DijkstraVisitor,
+          class PredecessorMap, class DistanceMap,
+          class WeightMap, class IndexMap, class Compare, class Combine,
+          class DistZero, class ColorMap&gt;
+void
+dijkstra_shortest_paths_no_init
+  (const Graph&amp; g,
+   typename graph_traits&lt;Graph&gt;::vertex_descriptor s,
+   PredecessorMap predecessor, DistanceMap distance, WeightMap weight,
+   IndexMap index_map,
+   Compare compare, Combine combine, DistZero zero,
+   DijkstraVisitor vis, ColorMap color = <i>default</i>);
+</PRE>
+
+<P>
+This algorithm&nbsp;[<A HREF="bibliography.html#dijkstra59">10</A>,<A
+HREF="bibliography.html#clr90">8</A>] solves the single-source
+shortest-paths problem on a weighted, directed or undirected graph for
+the case where all edge weights are nonnegative.  Use the Bellman-Ford
+algorithm for the case when some edge weights are negative.  Use
+breadth-first search instead of Dijkstra's algorithm when all edge
+weights are equal to one.  For the definition of the shortest-path
+problem see Section <A
+HREF="graph_theory_review.html#sec:shortest-paths-algorithms">Shortest-Paths
+Algorithms</A> for some background to the shortest-path problem.
+</P>
+
+<P>
+There are two main options for obtaining output from the
+<tt>dijkstra_shortest_paths()</tt> function. If you provide a
+distance property map through the <tt>distance_map()</tt> parameter
+then the shortest distance from the source vertex to every other
+vertex in the graph will be recorded in the distance map. Also you can
+record the shortest paths tree in a predecessor map: for each vertex
+<i>u in V</i>, <i>p[u]</i> will be the predecessor of <i>u</i> in
+the shortest paths tree (unless <i>p[u] = u</i>, in which case <i>u</i> is
+either the source or a vertex unreachable from the source).  In
+addition to these two options, the user can provide their own
+custom-made visitor that takes actions during any of the
+algorithm's event points.</P>
+
+<P>
+Dijkstra's algorithm finds all the shortest paths from the source
+vertex to every other vertex by iteratively ``growing'' the set of
+vertices <i>S</i> to which it knows the shortest path. At each step of
+the algorithm, the next vertex added to <i>S</i> is determined by a
+priority queue.  The queue contains the vertices in <i>V - S</i><a
+href="#1">[1]</a> prioritized by their distance label, which is the
+length of the shortest path seen so far for each vertex. The vertex
+<i>u</i> at the top of the priority queue is then added to <i>S</i>,
+and each of its out-edges is relaxed: if the distance to <i>u</i> plus
+the weight of the out-edge <i>(u,v)</i> is less than the distance
+label for <i>v</i> then the estimated distance for vertex <i>v</i> is
+reduced.  The algorithm then loops back, processing the next vertex at
+the top of the priority queue. The algorithm finishes when the
+priority queue is empty.
+</P>
+<P>
+The algorithm uses color markers (white, gray, and black) to keep
+track of which set each vertex is in. Vertices colored black are in
+<i>S</i>. Vertices colored white or gray are in <i>V-S</i>. White vertices have
+not yet been discovered and gray vertices are in the priority queue.
+By default, the algorithm will allocate an array to store a color
+marker for each vertex in the graph. You can provide your own storage
+and access for colors with the <tt>color_map()</tt> parameter.
+</P>
+<p>
+The following is the pseudo-code for Dijkstra's single-source shortest
+paths algorithm. <i>w</i> is the edge weight, <i>d</i> is the distance label,
+and <i>p</i> is the predecessor of each vertex which is used to encode
+the shortest paths tree. <i>Q</i> is a priority queue that supports the
+DECREASE-KEY operation.  The visitor event points for the algorithm are
+indicated by the labels on the right.
+</p>
+
+<table>
+<tr>
+<td valign="top">
+<pre>
+DIJKSTRA(<i>G</i>, <i>s</i>, <i>w</i>)
+  <b>for</b> each vertex <i>u in V</i> <b>(This loop is not run in dijkstra_shortest_paths_no_init)</b>
+    <i>d[u] := infinity</i> 
+    <i>p[u] := u</i> 
+    <i>color[u] :=</i> WHITE
+  <b>end for</b>
+  <i>color[s] := </i>GRAY 
+  <i>d[s] := 0</i> 
+  INSERT(<i>Q</i>, <i>s</i>)
+  <b>while</b> (<i>Q != &Oslash;</i>)
+    <i>u :=</i> EXTRACT-MIN(<i>Q</i>)
+    <i>S := S U { u }</i>
+    <b>for</b> each vertex <i>v in Adj[u]</i>
+      <b>if</b> (<i>w(u,v) + d[u] < d[v]</i>)
+        <i>d[v] := w(u,v) + d[u]</i>
+        <i>p[v] := u</i> 
+        <b>if</b> (<i>color[v] =</i> WHITE) 
+          <i>color[v] :=</i> GRAY
+          INSERT(<i>Q</i>, <i>v</i>) 
+        <b>else if</b> (<i>color[v] =</i> GRAY)
+          DECREASE-KEY(<i>Q</i>, <i>v</i>)
+      <b>else</b>
+        <i>...</i>
+    <b>end for</b>
+    <i>color[u] :=</i> BLACK
+  <b>end while</b>
+  return (<i>d</i>, <i>p</i>)
+</pre>
+</td>
+<td valign="top">
+<pre>
+
+initialize vertex <i>u</i>
+
+
+
+
+
+
+discover vertex <i>s</i>
+
+examine vertex <i>u</i>
+
+examine edge <i>(u,v)</i>
+
+edge <i>(u,v)</i> relaxed
+
+
+
+discover vertex <i>v</i>
+
+
+
+edge <i>(u,v)</i> not relaxed
+
+finish vertex <i>u</i>
+</pre>
+</td>
+</tr>
+</table>
+
+<h3>Where Defined</h3>
+
+<a href="../../../boost/graph/dijkstra_shortest_paths.hpp"><tt>boost/graph/dijkstra_shortest_paths.hpp</tt></a>
+
+<h3>Parameters</h3>
+
+IN: <tt>const Graph&amp; g</tt> 
+<blockquote>
+  The graph object on which the algorithm will be applied.
+  The type <tt>Graph</tt> must be a model of 
+  <a href="./VertexListGraph.html">Vertex List Graph</a>
+  and <a href="./IncidenceGraph.html">Incidence Graph</a>.<br>
+
+  <b>Python</b>: The parameter is named <tt>graph</tt>.
+</blockquote>
+
+IN: <tt>vertex_descriptor s</tt> 
+<blockquote>
+  The source vertex. All distance will be calculated from this vertex,
+  and the shortest paths tree will be rooted at this vertex.<br>
+
+  <b>Python</b>: The parameter is named <tt>root_vertex</tt>.
+</blockquote>
+
+<h3>Named Parameters</h3>
+
+IN: <tt>weight_map(WeightMap w_map)</tt>   
+<blockquote>
+  The weight or ``length'' of each edge in the graph. The weights
+  must all be non-negative, and the algorithm will throw a
+  <a href="./exception.html#negative_edge"><tt>negative_edge</tt></a> 
+  exception is one of the edges is negative.
+  The type <tt>WeightMap</tt> must be a model of
+  <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a>. The edge descriptor type of
+  the graph needs to be usable as the key type for the weight
+  map. The value type for this map must be
+  the same as the value type of the distance map.<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>
+  <b>Python default</b>: <tt>graph.get_edge_double_map("weight")</tt>
+</blockquote>
+
+IN: <tt>vertex_index_map(VertexIndexMap i_map)</tt> 
+<blockquote>
+  This maps each vertex to an integer in the range <tt>[0,
+    num_vertices(g))</tt>. This is necessary for efficient updates of the
+  heap data structure&nbsp;[<A
+  HREF="bibliography.html#driscoll88">61</A>] when an edge is relaxed.
+  The type 
+  <tt>VertexIndexMap</tt> must be a model of
+  <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a>. The value type of the map must be an
+  integer type. The vertex descriptor type of the graph needs to be
+  usable as the key type of the map.<br>
+  <b>Default:</b> <tt>get(vertex_index, g)</tt>.
+    Note: if you use this default, make sure your graph has
+    an internal <tt>vertex_index</tt> property. For example,
+    <tt>adjacency_list</tt> with <tt>VertexList=listS</tt> does
+    not have an internal <tt>vertex_index</tt> property.
+   <br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+OUT: <tt>predecessor_map(PredecessorMap p_map)</tt> 
+<blockquote>
+  The predecessor map records the edges in the shortest path tree, the tree computed
+  by the traversal of the graph. Upon completion of the algorithm, the edges 
+  <i>(p[u],u)</i> for all <i>u in V</i> are in the tree.  The shortest path
+  from vertex <i>s</i> to each vertex <i>v</i> in the graph consists of the
+  vertices <i>v</i>, <i>p[v]</i>, <i>p[p[v]]</i>, and so on until <i>s</i> is
+  reached, in reverse order.  The
+  tree is not guaranteed to be a minimum spanning tree. If <i>p[u] =
+  u</i> then <i>u</i> is either the source vertex or a vertex that is
+  not reachable from the source.  The <tt>PredecessorMap</tt> type
+  must be a <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a> whose key and value types are the same as the vertex
+  descriptor type of the graph.<br>
+  <b>Default:</b> <tt>dummy_property_map</tt><br>
+
+  <b>Python</b>: Must be a <tt>vertex_vertex_map</tt> for the graph.<br>
+</blockquote>
+
+UTIL/OUT: <tt>distance_map(DistanceMap d_map)</tt> 
+<blockquote>
+  The shortest path weight from the source vertex <tt>s</tt> to each
+  vertex in the graph <tt>g</tt> is recorded in this property map. The
+  shortest path weight is the sum of the edge weights along the
+  shortest path.  The type <tt>DistanceMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a>. The vertex descriptor type of the graph needs to
+  be usable as the key type of the distance map. 
+
+  The value type of the distance map is the element type of a <a
+  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.boost.org/sgi/stl/StrictWeakOrdering.html">
+  StrictWeakOrdering</a> provided by the <tt>compare</tt> function
+  object.<br>
+  <b>Default:</b> <a
+  href="../../property_map/doc/iterator_property_map.html">
+  <tt>iterator_property_map</tt></a> created from a
+  <tt>std::vector</tt> of the <tt>WeightMap</tt>'s value type of size
+  <tt>num_vertices(g)</tt> and using the <tt>i_map</tt> for the index
+  map.<br>
+
+  <b>Python</b>: Must be a <tt>vertex_double_map</tt> for the graph.<br>
+</blockquote>
+
+IN: <tt>distance_compare(CompareFunction cmp)</tt> 
+<blockquote>
+  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.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>
+
+  <b>Default:</b>
+  <tt>std::less&lt;D&gt;</tt> with <tt>D=typename
+  property_traits&lt;DistanceMap&gt;::value_type</tt><br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+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.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>std::plus&lt;D&gt;</tt> with
+   <tt>D=typename property_traits&lt;DistanceMap&gt;::value_type</tt><br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+IN: <tt>distance_inf(D inf)</tt> 
+<blockquote>
+  The <tt>inf</tt> object must be the greatest value of any <tt>D</tt> object.
+  That is, <tt>compare(d, inf) == true</tt> for any <tt>d != inf</tt>.
+  The type <tt>D</tt> is the value type of the <tt>DistanceMap</tt>.  Edges
+  are assumed to have a weight less than (using <tt>distance_compare</tt> for
+  comparison) this value.<br>
+  <b>Default:</b> <tt>std::numeric_limits&lt;D&gt;::max()</tt><br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+IN: <tt>distance_zero(D zero)</tt> 
+<blockquote>
+  The <tt>zero</tt> value must be the identity element for the
+  <a href="./Monoid.html">Monoid</a> formed by the distance values
+  and the <tt>combine</tt> function object.
+  The type <tt>D</tt> is the value type of the <tt>DistanceMap</tt>.<br>
+  <b>Default:</b> <tt>D()</tt>with
+   <tt>D=typename property_traits&lt;DistanceMap&gt;::value_type</tt><br>
+
+  <b>Python</b>: Unsupported parameter.
+</blockquote>
+
+UTIL/OUT: <tt>color_map(ColorMap c_map)</tt> 
+<blockquote>
+  This is used during the execution of the algorithm to mark the
+  vertices. The vertices start out white and become gray when they are
+  inserted in the queue. They then turn black when they are removed
+  from the queue. At the end of the algorithm, vertices reachable from
+  the source vertex will have been colored black. All other vertices
+  will still be white. The type <tt>ColorMap</tt> must be a model of
+  <a href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a>. A vertex descriptor must be usable as the key type
+  of the map, and the value type of the map must be a model of
+  <a href="./ColorValue.html">Color Value</a>.<br>
+  <b>Default:</b> an <a
+  href="../../property_map/doc/iterator_property_map.html">
+  <tt>iterator_property_map</tt></a> created from a <tt>std::vector</tt>
+  of <tt>default_color_type</tt> of size <tt>num_vertices(g)</tt> and
+  using the <tt>i_map</tt> for the index map.<br>
+
+  <b>Python</b>: The color map must be a <tt>vertex_color_map</tt> for
+  the graph.
+</blockquote>
+  
+OUT: <tt>visitor(DijkstraVisitor v)</tt>  
+<blockquote>
+  Use this to specify actions that you would like to happen
+  during certain event points within the algorithm.
+  The type <tt>DijkstraVisitor</tt> must be a model of the
+  <a href="./DijkstraVisitor.html">Dijkstra Visitor</a> concept. 
+ The visitor object is passed by value <a
+  href="#2">[2]</a>.<br>
+  <b>Default:</b> <tt>dijkstra_visitor&lt;null_visitor&gt;</tt><br>
+
+  <b>Python</b>: The parameter should be an object that derives from
+  the <a
+  href="DijkstraVisitor.html#python"><tt>DijkstraVisitor</tt></a> type
+  of the graph.
+</blockquote>
+
+
+<H3>Complexity</H3>
+
+<P>
+The time complexity is <i>O(V log V + E)</i>.
+
+
+<h3>Visitor Event Points</h3>
+
+<ul>
+<li><b><tt>vis.initialize_vertex(u, g)</tt></b>
+  is invoked on each vertex in the graph before the start of the
+  algorithm.
+<li><b><tt>vis.examine_vertex(u, g)</tt></b>
+  is invoked on a vertex as it is removed from the priority queue
+  and added to set <i>S</i>. At this point we know that <i>(p[u],u)</i>
+  is a shortest-paths tree edge so 
+  <i>d[u] = delta(s,u) = d[p[u]] + w(p[u],u)</i>. Also, the distances 
+  of the examined vertices is monotonically increasing
+  <i>d[u<sub>1</sub>] <= d[u<sub>2</sub>] <= d[u<sub>n</sub>]</i>. 
+<li><b><tt>vis.examine_edge(e, g)</tt></b>
+  is invoked on each out-edge of a vertex immediately after it has
+  been added to set <i>S</i>. 
+<li><b><tt>vis.edge_relaxed(e, g)</tt></b>
+  is invoked on edge <i>(u,v)</i> if <i>d[u] + w(u,v) < d[v]</i>.
+  The edge <i>(u,v)</i> that participated in the last
+  relaxation for vertex <i>v</i> is an edge in the shortest paths tree. 
+<li><b><tt>vis.discover_vertex(v, g)</tt></b>
+  is invoked on vertex <i>v</i> when the edge 
+  <i>(u,v)</i> is examined and <i>v</i> is WHITE. Since
+  a vertex is colored GRAY when it is discovered,
+  each reachable vertex is discovered exactly once. This
+  is also when the vertex is inserted into the priority queue.
+<li><b><tt>vis.edge_not_relaxed(e, g)</tt></b>
+  is invoked if the edge is not relaxed (see above).
+<li><b><tt>vis.finish_vertex(u, g)</tt></b>
+   is invoked on a vertex after all of its out edges have
+  been examined.
+</ul>
+
+<H3>Example</H3>
+
+<P>
+See <a href="../example/dijkstra-example.cpp">
+<TT>example/dijkstra-example.cpp</TT></a> for an example of using Dijkstra's
+algorithm.
+
+<H3>See also</H3> <a href="dijkstra_shortest_paths_no_color_map.html">dijkstra_shortest_paths_no_color_map</a> for a version of Dijkstra's shortest path that does not use a color map.
+
+<H3>Notes</H3>
+
+<a name="1">[1]</a>
+The algorithm used here saves a little space by not putting all <i>V -
+S</i> vertices in the priority queue at once, but instead only those
+vertices in <i>V - S</i> that are discovered and therefore have a
+distance less than infinity.
+
+<p><a name="2">[2]</a> 
+  Since the visitor parameter is passed by value, if your visitor
+  contains state then any changes to the state during the algorithm
+  will be made to a copy of the visitor object, not the visitor object
+  passed in. Therefore you may want the visitor to hold this state by
+  pointer or reference.
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 

doc/dijkstra_shortest_paths_no_color_map.html

@@ -0,0 +1,394 @@
+<HTML>
+<!--
+     Copyright (c) Michael Hansen 2009
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Dijkstra's Shortest Paths (No Color Map)</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><A NAME="sec:dijkstra"></A>
+<TT>dijkstra_shortest_paths_no_color_map</TT>
+</H1>
+
+<P>
+<PRE>
+<i>// named parameter version</i>
+template &lt;typename Graph, typename Param, typename Tag, typename Rest&gt;
+void dijkstra_shortest_paths_no_color_map
+  (const Graph&amp; graph,
+   typename graph_traits&lt;Graph&gt;::vertex_descriptor start_vertex,
+   const bgl_named_params<Param,Tag,Rest>& params);
+   
+<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.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,
+   typename graph_traits&lt;Graph&gt;::vertex_descriptor start_vertex, 
+   PredecessorMap predecessor_map, DistanceMap distance_map, WeightMap weight_map, 
+   VertexIndexMap index_map,
+   DistanceCompare distance_compare, DistanceWeightCombine distance_weight_combine,
+   DistanceInfinity distance_infinity, DistanceZero distance_zero);
+
+<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.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,
+   typename graph_traits&lt;Graph&gt;::vertex_descriptor start_vertex, 
+   PredecessorMap predecessor_map, DistanceMap distance_map, WeightMap weight_map, 
+   VertexIndexMap index_map,
+   DistanceCompare distance_compare, DistanceWeightCombine distance_weight_combine,
+   DistanceInfinity distance_infinity, DistanceZero distance_zero);
+</PRE>
+
+<P>
+This algorithm&nbsp;[<A HREF="bibliography.html#dijkstra59">10</A>,<A
+HREF="bibliography.html#clr90">8</A>] solves the single-source
+shortest-paths problem on a weighted, directed or undirected graph for
+the case where all edge weights are nonnegative.  Use the Bellman-Ford
+algorithm for the case when some edge weights are negative.  Use
+breadth-first search instead of Dijkstra's algorithm when all edge
+weights are equal to one.  For the definition of the shortest-path
+problem see Section <A
+HREF="graph_theory_review.html#sec:shortest-paths-algorithms">Shortest-Paths
+Algorithms</A> for some background to the shortest-path problem.
+</P>
+
+<P>
+	<tt>dijkstra_shortest_paths_no_color_map</tt> differs from the original <tt>dijkstra_shortest_paths</tt> algorithm by not using a color map to identify vertices as discovered or undiscovered.  Instead, this is done with the distance map: a vertex <i>u</i> such that <i>distance_compare(distance_map[u], distance_infinity) == false</i> is considered to be undiscovered.  Note that this means that edges with infinite weight will not work correctly in this algorithm.
+</P>
+
+<P>
+There are two main options for obtaining output from the
+<tt>dijkstra_shortest_paths_no_color_map()</tt> function. If you provide a
+distance property map through the <tt>distance_map()</tt> parameter
+then the shortest distance from the start vertex to every other
+vertex in the graph will be recorded in the distance map. Also you can
+record the shortest paths tree in a predecessor map: for each vertex
+<i>u in V</i>, <i>p[u]</i> will be the predecessor of <i>u</i> in
+the shortest paths tree (unless <i>p[u] = u</i>, in which case <i>u</i> is
+either the source or a vertex unreachable from the source).  In
+addition to these two options, the user can provide their own
+custom-made visitor that takes actions during any of the
+algorithm's event points <a href="#4">[4]</a>.</P>
+
+<P>
+Dijkstra's algorithm finds all the shortest paths from the source
+vertex to every other vertex by iteratively &quot;growing&quot; the set of
+vertices <i>S</i> to which it knows the shortest path. At each step of
+the algorithm, the next vertex added to <i>S</i> is determined by a
+priority queue.  The queue contains the vertices in <i>V - S</i><a
+href="#1">[1]</a> prioritized by their distance label, which is the
+length of the shortest path seen so far for each vertex. The vertex
+<i>u</i> at the top of the priority queue is then added to <i>S</i>,
+and each of its out-edges is relaxed: if the distance to <i>u</i> plus
+the weight of the out-edge <i>(u,v)</i> is less than the distance
+label for <i>v</i> then the estimated distance for vertex <i>v</i> is
+reduced.  The algorithm then loops back, processing the next vertex at
+the top of the priority queue. The algorithm finishes when the
+priority queue is empty.
+</P>
+<p>
+The following is the pseudo-code for Dijkstra's single-source shortest
+paths algorithm. <i>w</i> is the edge weight, <i>d</i> is the distance label,
+and <i>p</i> is the predecessor of each vertex which is used to encode
+the shortest paths tree. <i>Q</i> is a priority queue that supports the
+DECREASE-KEY operation.  The visitor event points for the algorithm are
+indicated by the labels on the right.
+</p>
+
+<table>
+<tr>
+<td valign="top">
+<pre>
+DIJKSTRA(<i>G</i>, <i>s</i>, <i>w</i>)
+  <i>d[s] := 0</i> 
+  INSERT(<i>Q</i>, <i>s</i>)
+  <b>while</b> (<i>Q != &Oslash;</i>)
+    <i>u :=</i> EXTRACT-MIN(<i>Q</i>)
+    <b>for</b> each vertex <i>v in Adj[u]</i>
+      <b>if</b> (<i>w(u,v) + d[u] < d[v]</i>)
+        <i>d[v] := w(u,v) + d[u]</i>
+        <i>p[v] := u</i> 
+        <b>if</b> (<i>d[v]</i> was originally infinity) 
+          INSERT(<i>Q</i>, <i>v</i>)   
+        <b>else</b>
+          DECREASE-KEY(<i>Q</i>, <i>v</i>)
+      <b>else</b>
+      	...
+    <b>end for</b>
+  <b>end while</b>
+  return (<i>d</i>, <i>p</i>)
+</pre>
+</td>
+<td valign="top">
+<pre>
+
+
+discover vertex <i>s</i>
+
+examine vertex <i>u</i>
+examine edge <i>(u,v)</i>
+
+edge <i>(u,v)</i> relaxed
+
+
+discover vertex <i>v</i>
+
+
+edge <i>(u,v)</i> not relaxed
+
+finish vertex <i>u</i>
+</pre>
+</td>
+</tr>
+</table>
+
+<h3>Where Defined</h3>
+
+<a href="../../../boost/graph/dijkstra_shortest_paths_no_color_map.hpp"><tt>boost/graph/dijkstra_shortest_paths_no_color_map.hpp</tt></a>
+
+<h3>Parameters</h3>
+
+IN: <tt>const Graph&amp; graph</tt> 
+<blockquote>
+  The graph object on which the algorithm will be applied.
+  The type <tt>Graph</tt> must be a model of 
+  <a href="./VertexListGraph.html">Vertex List Graph</a>
+  and <a href="./IncidenceGraph.html">Incidence Graph</a>.<br>
+</blockquote>
+
+IN: <tt>vertex_descriptor start_vertex</tt> 
+<blockquote>
+  The source vertex. All distance will be calculated from this vertex,
+  and the shortest paths tree will be rooted at this vertex.<br>
+</blockquote>
+
+<h3>Named Parameters</h3>
+
+IN: <tt>weight_map(WeightMap weight_map)</tt>   
+<blockquote>
+  The weight or ``length'' of each edge in the graph. The weights
+  must all be non-negative and non-infinite <a href="#3">[3]</a>. The algorithm will throw a
+  <a href="./exception.html#negative_edge"><tt>negative_edge</tt></a> 
+  exception is one of the edges is negative.
+  The type <tt>WeightMap</tt> must be a model of
+  <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a>. The edge descriptor type of
+  the graph needs to be usable as the key type for the weight
+  map. The value type for this map must be
+  the same as the value type of the distance map.<br>
+  <b>Default:</b>  <tt>get(edge_weight, graph)</tt><br>
+</blockquote>
+
+IN: <tt>index_map(VertexIndexMap index_map)</tt> 
+<blockquote>
+  This maps each vertex to an integer in the range <tt>[0,
+    num_vertices(graph))</tt>. This is necessary for efficient updates of the
+  heap data structure&nbsp;[<A
+  HREF="bibliography.html#driscoll88">61</A>] when an edge is relaxed.
+  The type 
+  <tt>VertexIndexMap</tt> must be a model of
+  <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a>. The value type of the map must be an
+  integer type. The vertex descriptor type of the graph needs to be
+  usable as the key type of the map.<br>
+  <b>Default:</b> <tt>get(vertex_index, graph)</tt>.
+    Note: if you use this default, make sure your graph has
+    an internal <tt>vertex_index</tt> property. For example,
+    <tt>adjacency_list</tt> with <tt>VertexList=listS</tt> does
+    not have an internal <tt>vertex_index</tt> property.
+   <br>
+</blockquote>
+
+OUT: <tt>predecessor_map(PredecessorMap predecessor_map)</tt> 
+<blockquote>
+  The predecessor map records the edges in the minimum spanning
+  tree. Upon completion of the algorithm, the edges <i>(p[u],u)</i>
+  for all <i>u in V</i> are in the minimum spanning tree. If <i>p[u] =
+  u</i> then <i>u</i> is either the source vertex or a vertex that is
+  not reachable from the source.  The <tt>PredecessorMap</tt> type
+  must be a <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a> whose key and value types are the same as the vertex
+  descriptor type of the graph.<br>
+  <b>Default:</b> <tt>dummy_property_map</tt><br>
+
+  <b>Python</b>: Must be a <tt>vertex_vertex_map</tt> for the graph.<br>
+</blockquote>
+
+UTIL/OUT: <tt>distance_map(DistanceMap distance_map)</tt> 
+<blockquote>
+  The shortest path weight from the source vertex <tt>start_vertex</tt> to each
+  vertex in the graph <tt>graph</tt> is recorded in this property map. The
+  shortest path weight is the sum of the edge weights along the
+  shortest path.  The type <tt>DistanceMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a>. The vertex descriptor type of the graph needs to
+  be usable as the key type of the distance map. 
+
+  The value type of the distance map is the element type of a <a
+  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.boost.org/sgi/stl/StrictWeakOrdering.html">
+  StrictWeakOrdering</a> provided by the <tt>distance_compare</tt> function
+  object.<br>
+  <b>Default:</b> <a
+  href="../../property_map/doc/iterator_property_map.html">
+  <tt>iterator_property_map</tt></a> created from a
+  <tt>std::vector</tt> of the <tt>WeightMap</tt>'s value type of size
+  <tt>num_vertices(graph)</tt> and using the <tt>index_map</tt> for the index
+  map.<br>
+</blockquote>
+
+IN: <tt>distance_compare(CompareFunction distance_compare)</tt> 
+<blockquote>
+  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.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>
+
+  <b>Default:</b>
+  <tt>std::less&lt;D&gt;</tt> with <tt>D=typename
+  property_traits&lt;DistanceMap&gt;::value_type</tt><br>
+</blockquote>
+
+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.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>boost::closed_plus&lt;D&gt;</tt> with
+   <tt>D=typename property_traits&lt;DistanceMap&gt;::value_type</tt><br>
+</blockquote>
+
+IN: <tt>distance_inf(D distance_infinity)</tt> 
+<blockquote>
+  The <tt>distance_infinity</tt> object must be the greatest value of any <tt>D</tt> object.
+  That is, <tt>distance_compare(d, distance_infinity) == true</tt> for any <tt>d != distance_infinity</tt>.
+  The type <tt>D</tt> is the value type of the <tt>DistanceMap</tt>.  All edges
+  are assumed to have weight less than (by <tt>distance_compare</tt>) this
+  value.<br>
+  <b>Default:</b> <tt>std::numeric_limits&lt;D&gt;::max()</tt><br>
+</blockquote>
+
+IN: <tt>distance_zero(D distance_zero)</tt> 
+<blockquote>
+  The <tt>distance_zero</tt> value must be the identity element for the
+  <a href="./Monoid.html">Monoid</a> formed by the distance values
+  and the <tt>distance_weight_combine</tt> function object.
+  The type <tt>D</tt> is the value type of the <tt>DistanceMap</tt>.<br>
+  <b>Default:</b> <tt>D()</tt>with
+   <tt>D=typename property_traits&lt;DistanceMap&gt;::value_type</tt><br>
+</blockquote>
+  
+OUT: <tt>visitor(DijkstraVisitor v)</tt>  
+<blockquote>
+  Use this to specify actions that you would like to happen
+  during certain event points within the algorithm.
+  The type <tt>DijkstraVisitor</tt> must be a model of the
+  <a href="./DijkstraVisitor.html">Dijkstra Visitor</a> concept. 
+ The visitor object is passed by value <a
+  href="#2">[2]</a>.<br>
+  <b>Default:</b> <tt>dijkstra_visitor&lt;null_visitor&gt;</tt><br>
+</blockquote>
+
+
+<H3>Complexity</H3>
+
+<P>
+The time complexity is <i>O(V log V + E)</i>.
+
+
+<h3>Visitor Event Points</h3>
+
+<ul>
+<li><b><tt>vis.initialize_vertex(u, g)</tt></b>
+  is invoked on each vertex in the graph before the start of the
+  algorithm.
+<li><b><tt>vis.examine_vertex(u, g)</tt></b>
+  is invoked on a vertex as it is removed from the priority queue
+  and added to set <i>S</i>. At this point we know that <i>(p[u],u)</i>
+  is a shortest-paths tree edge so 
+  <i>d[u] = delta(s,u) = d[p[u]] + w(p[u],u)</i>. Also, the distances 
+  of the examined vertices is monotonically increasing
+  <i>d[u<sub>1</sub>] <= d[u<sub>2</sub>] <= d[u<sub>n</sub>]</i>. 
+<li><b><tt>vis.examine_edge(e, g)</tt></b>
+  is invoked on each out-edge of a vertex immediately after it has
+  been added to set <i>S</i>. 
+<li><b><tt>vis.edge_relaxed(e, g)</tt></b>
+  is invoked on edge <i>(u,v)</i> if <i>d[u] + w(u,v) < d[v]</i>.
+  The edge <i>(u,v)</i> that participated in the last
+  relaxation for vertex <i>v</i> is an edge in the shortest paths tree. 
+<li><b><tt>vis.discover_vertex(v, g)</tt></b>
+  is invoked on vertex <i>v</i> when the edge 
+  <i>(u,v)</i> is examined and <i>v</i> has not yet been discovered (i.e. its distance was infinity before relaxation was attempted on the edge).  This
+  is also when the vertex is inserted into the priority queue.
+<li><b><tt>vis.edge_not_relaxed(e, g)</tt></b>
+  is invoked if the edge is not relaxed (see above).
+<li><b><tt>vis.finish_vertex(u, g)</tt></b>
+   is invoked on a vertex after all of its out edges have
+  been examined.
+</ul>
+
+<H3>Example</H3>
+
+<P>
+See <a href="../example/dijkstra-no-color-map-example.cpp">
+<TT>example/dijkstra-no-color-map-example.cpp</TT></a> for an example of using Dijkstra's algorithm.
+
+<H3>See also</H3> <a href="dijkstra_shortest_paths.html">dijkstra_shortest_paths</a> for a version of Dijkstra's shortest path that uses a color map.
+
+<H3>Notes</H3>
+
+<p>Based on the documentation for <a href="dijkstra_shortest_paths.html">dijkstra_shortest_paths</a>.
+
+<p><a name="1">[1]</a>
+The algorithm used here saves a little space by not putting all <i>V -
+S</i> vertices in the priority queue at once, but instead only those
+vertices in <i>V - S</i> that are discovered and therefore have a
+distance less than infinity.
+
+<p><a name="2">[2]</a> 
+  Since the visitor parameter is passed by value, if your visitor
+  contains state then any changes to the state during the algorithm
+  will be made to a copy of the visitor object, not the visitor object
+  passed in. Therefore you may want the visitor to hold this state by
+  pointer or reference.
+  
+<p><a name="3">[3]</a> 
+  The algorithm will not work correctly if any of the edge weights are equal to infinity since the infinite distance value is used to determine if a vertex has been discovered.
+  
+<p><a name="4">[4]</a> 
+  Calls to the visitor events occur in the same order as <tt>dijkstra_shortest_paths</tt> (i.e. <i>discover_vertex(u)</i> will always be called after <i>examine_vertex(u)</i> for an undiscovered vertex <i>u</i>).  However, the vertices of the graph given to <i>dijkstra_shortest_paths_no_color_map</i> will <b>not</b> necessarily be visited in the same order as <i>dijkstra_shortest_paths</i>.
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2009</TD><TD>
+Trustees of Indiana University</TD></TR></TABLE>
+
+</BODY>
+</HTML> 

doc/dijkstra_visitor.html

@@ -0,0 +1,125 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: dijkstra_visitor</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1>
+<pre>
+dijkstra_visitor&lt;EventVisitorList&gt;
+</pre>
+</H1>
+
+This class is an adapter that converts a list of <a
+href="./EventVisitor.html">EventVisitor</a>s (constructed using
+<tt>std::pair</tt>) into a <a
+href="./DijkstraVisitor.html">DijkstraVisitor</a>.
+
+
+<h3>Example</h3>
+
+This is an excerpt from <a
+href="../example/dave.cpp"><tt>examples/dave.cpp</tt></a>
+where the <tt>copy_graph</tt> single-event visitor
+is used to create a copy the shortest-paths search-tree calculated
+by Dijkstra's algorithm.
+
+<pre>
+boost::dijkstra_shortest_paths
+  (G, vertex(a, G), 
+   distance_map(make_iterator_property_map(distance.begin(), vertex_id, distance[0])).
+   predecessor_map(make_iterator_property_map(parent.begin(), vertex_id, parent[0])).
+   visitor(make_dijkstra_visitor(copy_graph(G_copy, on_examine_edge()))));
+</pre>
+
+
+<h3>Model of</h3>
+
+<a href="./DijkstraVisitor.html">Dijkstra Visitor</a>
+
+<H3>Template Parameters</H3>
+
+<P>
+<TABLE border>
+<TR>
+<th>Parameter</th><th>Description</th><th>Default</th>
+</tr>
+
+<TR><TD><TT>EventVisitorList</TT></TD>
+<TD>
+A list of <a href="./EventVisitor.html">EventVisitor</a>'s created
+with <tt>std::pair</tt>.
+</TD>
+<TD><TT><a href="./null_visitor.html"><tt>null_visitor</tt></a></TT></TD>
+</TR>
+
+</table>
+
+<H3>Where Defined</H3>
+
+<P>
+<a href="../../../boost/graph/dijkstra_shortest_paths.hpp">
+<TT>boost/graph/dijkstra_shortest_paths.hpp</TT></a>
+
+<h3>Member Functions</h3>
+
+This class implements all of the member functions required by <a
+href="./DijkstraVisitor.html">DijkstraVisitor</a>. In each
+function the appropriate event is dispatched to the <a
+href="./EventVisitor.html">EventVisitor</a> in the EventVisitorList.
+
+<h3>Non-Member Functions</h3>
+
+<table border>
+<tr>
+<th>Function</th><th>Description</th>
+</tr>
+
+<tr><td><tt>
+template &lt;class EventVisitorList&gt;<br>
+dijkstra_visitor&lt;EventVisitorList&gt;<br>
+make_dijkstra_visitor(EventVisitorList ev_list);
+</tt></td><td>
+Returns the event visitor list adapted to be a Dijkstra Visitor.
+</td></tr>
+
+</table>
+
+<h3>See Also</h3>
+
+<a href="./visitor_concepts.html">Visitor concepts</a>
+<p>
+The following are event visitors: <a
+ href="./predecessor_recorder.html"><tt>predecessor_recorder</tt></a>,
+<a href="./distance_recorder.html"><tt>distance_recorder</tt></a>
+<a href="./time_stamper.html"><tt>time_stamper</tt></a>,
+and <a href="./property_writer.html"><tt>property_writer</tt></a>.
+
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
+
+</BODY>
+</HTML> 

doc/directed_graph.html

@@ -0,0 +1,96 @@
+<HTML>
+<!--
+     Copyright (c) David Doria 2012
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Directed Graph</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><A NAME="sec:directed-graph-class"></A>
+<pre>
+directed_graph&lt;VertexProp, EdgeProp, GraphProp&gt;
+</pre>
+</H1>
+
+
+<P>
+The <tt>directed_graph</tt> class template is a simplified version
+of the BGL adjacency list. This class is provided for ease of use, but
+may not perform as well as custom-defined adjacency list classes. Instances
+of this template model the BidirectionalGraph, VertexIndexGraph, and
+EdgeIndexGraph concepts.
+
+<H3>Example</H3>
+
+A simple examples of creating a directed_graph is available here <a href="../../../libs/graph/example/directed_graph.cpp"><tt>libs/graph/example/directed_graph.cpp</tt></a>.
+<P>
+
+
+<PRE>
+  typedef boost::directed_graph&lt;&gt; Graph;
+  Graph g;
+  boost::graph_traits&lt;Graph&gt;::vertex_descriptor v0 = g.add_vertex();
+  boost::graph_traits&lt;Graph&gt;::vertex_descriptor v1 = g.add_vertex();
+
+  g.add_edge(v0, v1);
+</PRE>
+
+<H3>Template Parameters</H3>
+
+<P>
+<TABLE border>
+<TR>
+<th>Parameter</th><th>Description</th><th>Default</th>
+</tr>
+
+<TR><TD><TT>VertexProp</TT></TD>
+<TD>A property map for the graph vertices.</TD>
+<TD>&nbsp;</TD>
+</TR>
+
+<TR>
+<TD><TT>EdgeProp</TT></TD>
+<TD>A property map for the graph edges.</TD>
+<TD>&nbsp;</TD>
+</TR>
+
+<TR>
+<TD><TT>GraphProp</TT></TD>
+<TD>A property map for the graph itself.</TD>
+</TR>
+
+</TABLE>
+<P>
+
+<H3>Where Defined</H3>
+
+<P>
+<a href="../../../boost/graph/directed_graph.hpp"><TT>boost/graph/directed_graph.hpp</TT></a>
+
+<P>
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
+
+</BODY>
+</HTML> 

doc/distance_recorder.html

@@ -1,20 +1,16 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  We make no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>Boost Graph Library: distance_recorder</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -31,7 +27,7 @@ href="property_map.html">property map</a>) from some
 source vertex during a graph search. When applied to edge <i>e =
 (u,v)</i>, the distance of <i>v</i> is recorded to be one more than
 the distance of <i>u</i>. The distance recorder is typically used with
-the <tt>on_tree_edge</tt> or <tt>on_relax_edge</tt> events, and
+the <tt>on_tree_edge</tt> or <tt>on_relax_edge</tt> events and
 cannot be used with vertex events.
 
 <p>
@@ -68,7 +64,7 @@ See the example for <a href="./bfs_visitor.html"><tt>bfs_visitor</tt></a>.
 <TR><TD><TT>DistanceMap</TT></TD>
 <TD>
 A <a
-href="../../property_map/WritablePropertyMap.html">WritablePropertyMap</a>,
+href="../../property_map/doc/WritablePropertyMap.html">WritablePropertyMap</a>
 where the key type and the value type are the vertex descriptor type
 of the graph.
 </TD>
@@ -157,7 +153,7 @@ A convenient way to create a <tt>distance_recorder</tt>.
 <a href="./visitor_concepts.html">Visitor concepts</a>
 <p>
 The following are other event visitors: <a
- href="./distance_recorder.html"><tt>predecessor_recorder</tt></a>,
+ href="./predecessor_recorder.html"><tt>predecessor_recorder</tt></a>,
 <a href="./time_stamper.html"><tt>time_stamper</tt></a>,
 and <a href="./property_writer.html"><tt>property_writer</tt></a>.
 
@@ -166,14 +162,14 @@ and <a href="./property_writer.html"><tt>property_writer</tt></a>.
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~llee1>Lie-Quan Lee</A>, Univ.of Notre Dame (<A HREF="mailto:llee1@lsc.nd.edu">llee1@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~lums>Andrew Lumsdaine</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:lums@lsc.nd.edu">lums@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
 
 </BODY>

doc/edge_coloring.html

@@ -0,0 +1,98 @@
+<HTML>
+<!--
+  ~~ Copyright (c) Maciej Piechotka 2013
+  ~~
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+-->
+
+
+<Head>
+<Title>Boost Graph Library: Edge Coloring</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b"
+        ALINK="#ff0000">
+<IMG SRC="../../../boost.png"
+     ALT="C++ Boost" width="277" height="86">
+
+<BR Clear>
+
+<H1>
+<!-- <img src="figs/python.gif" alt="(Python)"/> -->
+<TT>edge_coloring</TT>
+</H1>
+
+
+<P>
+<DIV ALIGN="LEFT">
+<TABLE CELLPADDING=3 border>
+<TR><TH ALIGN="LEFT"><B>Graphs:</B></TH>
+<TD ALIGN="LEFT">undirected, loop-free</TD>
+</TR>
+<TR><TH ALIGN="LEFT"><B>Properties:</B></TH>
+<TD ALIGN="LEFT">color</TD>
+</TR>
+<TR><TH ALIGN="LEFT"><B>Complexity:</B></TH>
+<TD ALIGN="LEFT">time: <i>O(|E| |V|)</i> </TD>
+</TR>
+</TABLE>
+</DIV>
+
+
+<pre>
+  template &lt;class Graph, class ColorMap&gt;
+  typename boost::property_traits<ColorMap>::value_type
+  edge_coloring(const Graph &amp;g, ColorMap color);
+</pre>
+
+<p>Computes an edge coloring for the vertices in the graph, using
+an algorithm proposed by Misra et al. []. Given edges ordered
+e<sub>1</sub>, e<sub>2</sub>, ..., e<sub>n</sub> it assignes a
+colors c<sub>1</sub>, c<sub>2</sub>, ..., c<sub>n</sub> in a way
+that no vertex connects with 2 edges of the same color. Furthermore
+at most m + 1 colors are used.
+
+<!-- King, I.P. An automatic reordering scheme for simultaneous equations derived from network analysis. Int. J. Numer. Methods Engrg. 2 (1970), 523-533 -->
+
+<h3>Where defined</h3>
+<a href="../../../boost/graph/edge_coloring.hpp"><tt>boost/graph/edge_coloring.hpp</tt></a>
+
+<h3>Parameters</h3>
+
+IN: <tt>const Graph&amp; g</tt>
+<blockquote>
+  The graph object on which the algorithm will be applied. The type
+  <tt>Graph</tt> must be a model of <a href="EdgeListGraph.html">
+  Edge List Graph</a> and <a href="IncidenceGraph.html">Incidence
+  Graph</a>.
+</blockquote>
+
+OUT: <tt>ColorMap color</tt>
+<blockquote>
+  This property map records the colors of each edges. It must be a
+  model of <A HREF="../../property_map/doc/ReadWritePropertyMap.html">
+  Read/Write Property Map</A> whose key type is the same as the edge
+  descriptor type of the graph and whose value type is an integral type
+  that can store all values smaller or equal to m.
+</blockquote>
+
+
+<h3>Example</h3>
+
+See <A
+href="../example/edge_coloring.cpp"><tt>example/king_ordering.cpp</tt></A>.
+
+<h3>See Also</h3>
+
+<A href="./sequential_vertex_coloring.html">sequential vertex ordering</tt></A>.
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2013</TD><TD>
+Maciej Piechotka (<A HREF="mailto:uzytkownik2@gmail.com">uzytkownik2@gmail.com</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML>

doc/edge_list.html

@@ -1,20 +1,16 @@
 <HTML>
 <!--
-  -- Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
-  --
-  -- Permission to use, copy, modify, distribute and sell this software
-  -- and its documentation for any purpose is hereby granted without fee,
-  -- provided that the above copyright notice appears in all copies and
-  -- that both that copyright notice and this permission notice appear
-  -- in supporting documentation.  Silicon Graphics makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
 <Title>Boost Graph Library: Edge List Class</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
+<IMG SRC="../../../boost.png" 
      ALT="C++ Boost" width="277" height="86"> 
 
 <BR Clear>
@@ -108,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/Technology/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>
 
@@ -211,14 +207,14 @@ Returns the target vertex of edge <TT>e</TT>.
 <HR>
 <TABLE>
 <TR valign=top>
-<TD nowrap>Copyright &copy 2000</TD><TD>
-<A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:jsiek@lsc.nd.edu">jsiek@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~llee1>Lie-Quan Lee</A>, Univ.of Notre Dame (<A HREF="mailto:llee1@lsc.nd.edu">llee1@lsc.nd.edu</A>)<br>
-<A HREF=http://www.lsc.nd.edu/~lums>Andrew Lumsdaine</A>,
-Univ.of Notre Dame (<A
-HREF="mailto:lums@lsc.nd.edu">lums@lsc.nd.edu</A>)
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
 
 </BODY>

doc/edge_predecessor_recorder.html

@@ -0,0 +1,197 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: edge_predecessor_recorder</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1>
+<pre>
+edge_predecessor_recorder&lt;PredEdgeMap, EventTag&gt;
+</pre>
+</H1>
+
+This is an <a href="./EventVisitor.html">EventVisitor</a> that records
+the predecessor (or parent) edge of a vertex in a property
+map. This is particularly useful in graph search algorithms where
+recording the predecessors is an efficient way to encode the search
+tree that was traversed during the search. The edge predecessor recorder is
+typically used with the <tt>on_tree_edge</tt> or
+<tt>on_relax_edge</tt> events and cannot be used with vertex events.  This
+visitor is meant to be used instead of <a
+href="predecessor_recorder.html"><tt>predecessor_recorder</tt></a> when a
+graph has parallel edges and it is necessary to know which incoming edge a
+search algorithm
+used to get to a particular vertex.
+
+<p>
+<tt>edge_predecessor_recorder</tt> can be used with graph algorithms by
+wrapping it with an algorithm-specific adaptor, such as <a
+href="./bfs_visitor.html"><tt>bfs_visitor</tt></a> and <a
+href="./dfs_visitor.html"><tt>dfs_visitor</tt></a>. Also, this event
+visitor can be combined with other event visitors using
+<tt>std::pair</tt> to form an EventVisitorList.
+
+<p>
+Algorithms such as Dijkstra's and breadth-first search will not assign
+a predecessor edge to the source vertex (which is the root of the search
+tree). It is often useful to initialize the source vertex's
+predecessor to a special value, thereby identifying the root vertex.
+When using an algorithm like
+depth-first search that creates a forest (multiple search trees) it
+is useful to do the same for every vertex. This
+way all the root nodes can be distinguished.
+
+
+<!-- <h3>Example</h3>
+
+See the example for <a href="./bfs_visitor.html"><tt>bfs_visitor</tt></a>.
+-->
+
+<h3>Model of</h3>
+
+<a href="./EventVisitor.html">EventVisitor</a>
+
+
+<H3>Where Defined</H3>
+
+<P>
+<a href="../../../boost/graph/visitors.hpp">
+<TT>boost/graph/visitors.hpp</TT></a>
+
+<H3>Template Parameters</H3>
+
+<P>
+<TABLE border>
+<TR>
+<th>Parameter</th><th>Description</th><th>Default</th>
+</tr>
+
+<TR><TD><TT>PredEdgeMap</TT></TD>
+<TD>
+A <a
+href="../../property_map/doc/WritablePropertyMap.html">WritablePropertyMap</a>
+where the key and value types are the vertex and edge descriptor types, respectively, of the graph.
+</TD>
+<TD>&nbsp;</TD>
+</TR>
+
+<TR><TD><TT>EventTag</TT></TD>
+<TD>
+The tag to specify when the <tt>edge_predecessor_recorder</tt> should be
+applied during the graph algorithm. <tt>EventTag</tt> must be an
+edge event.
+</TD>
+<TD>&nbsp;</TD>
+</TR>
+
+</table>
+
+<H2>Associated Types</H2>
+
+<table border>
+
+<tr>
+<th>Type</th><th>Description</th>
+</tr>
+
+<tr>
+<td><tt>edge_predecessor_recorder::event_filter</tt></td>
+<td>
+This will be the same type as the template parameter <tt>EventTag</tt>.
+</td>
+</tr>
+
+</table>
+
+<h3>Member Functions</h3>
+
+<p>
+
+<table border>
+<tr>
+<th>Member</th><th>Description</th>
+</tr>
+
+<tr>
+<td><tt>
+edge_predecessor_recorder(PredEdgeMap pa);
+</tt></td>
+<td>
+Construct an edge predecessor recorder object with predecessor property map
+<tt>pa</tt>.
+</td>
+</tr>
+
+<tr>
+<td><tt>
+template &lt;class Edge, class Graph&gt;<br>
+void operator()(Edge e, const Graph& g);
+</tt></td>
+<td>
+Given edge <i>e = (u,v)</i>, this records <i>e</i> as the
+predecessor (or parent) edge of <i>v</i>.
+</td>
+</tr>
+
+</table>
+
+<h3>Non-Member Functions</h3>
+
+<table border>
+<tr>
+<th>Function</th><th>Description</th>
+</tr>
+
+<tr><td><tt>
+template &lt;class PredEdgeMap, class Tag&gt;<br>
+edge_predecessor_recorder&lt;PredEdgeMap, Tag&gt; <br>
+record_edge_predecessors(PredEdgeMap pa, Tag);
+</tt></td><td>
+A convenient way to create a <tt>edge_predecessor_recorder</tt>.
+</td></tr>
+
+</table>
+
+<h3>See Also</h3>
+
+<a href="./visitor_concepts.html">Visitor concepts</a>
+<p>
+The following are other event visitors: <a
+<a href="./distance_recorder.html"><tt>distance_recorder</tt></a>,
+<a href="./time_stamper.html"><tt>time_stamper</tt></a>,
+and <a href="./property_writer.html"><tt>property_writer</tt></a>.
+
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</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="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>
+
+</BODY>
+</HTML> 
+<!--  LocalWords:  PredEdgeMap EventTag EventVisitor map bfs dfs const
+ -->
+<!--  LocalWords:  EventVisitorList WritablePropertyMap Siek Univ Quan
+ -->
+<!--  LocalWords:  Lumsdaine
+ -->

doc/edmonds_karp_max_flow.html

@@ -0,0 +1,247 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Edmonds-Karp Maximum Flow</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><A NAME="sec:edmonds_karp_max_flow">
+<TT>edmonds_karp_max_flow</TT>
+</H1>
+
+<PRE>
+<i>// named parameter version</i>
+template &lt;class <a href="./Graph.html">Graph</a>, class P, class T, class R&gt;
+typename detail::edge_capacity_value&lt;Graph, P, T, R&gt;::value_type
+edmonds_karp_max_flow(Graph& g, 
+   typename graph_traits&lt;Graph&gt;::vertex_descriptor src,
+   typename graph_traits&lt;Graph&gt;::vertex_descriptor sink,
+   const bgl_named_params&lt;P, T, R&gt;&amp; params = <i>all defaults</i>)
+
+<i>// non-named parameter version</i>
+template &lt;class <a href="./Graph.html">Graph</a>, 
+	  class CapacityEdgeMap, class ResidualCapacityEdgeMap,
+	  class ReverseEdgeMap, class ColorMap, class PredEdgeMap&gt;
+typename property_traits&lt;CapacityEdgeMap&gt;::value_type
+edmonds_karp_max_flow(Graph&amp; g, 
+   typename graph_traits&lt;Graph&gt;::vertex_descriptor src,
+   typename graph_traits&lt;Graph&gt;::vertex_descriptor sink,
+   CapacityEdgeMap cap, ResidualCapacityEdgeMap res, ReverseEdgeMap rev, 
+   ColorMap color, PredEdgeMap pred)
+</PRE>
+
+<P>
+The <tt>edmonds_karp_max_flow()</tt> function calculates the maximum flow
+of a network. See Section <a
+href="./graph_theory_review.html#sec:network-flow-algorithms">Network
+Flow Algorithms</a> for a description of maximum flow.  The calculated
+maximum flow will be the return value of the function. The function
+also calculates the flow values <i>f(u,v)</i> for all <i>(u,v)</i> in
+<i>E</i>, which are returned in the form of the residual capacity
+<i>r(u,v) = c(u,v) - f(u,v)</i>. 
+
+<p>
+There are several special requirements on the input graph and property
+map parameters for this algorithm. First, the directed graph
+<i>G=(V,E)</i> that represents the network must be augmented to
+include the reverse edge for every edge in <i>E</i>.  That is, the
+input graph should be <i>G<sub>in</sub> = (V,{E U
+E<sup>T</sup>})</i>. The <tt>ReverseEdgeMap</tt> argument <tt>rev</tt>
+must map each edge in the original graph to its reverse edge, that is
+<i>(u,v) -> (v,u)</i> for all <i>(u,v)</i> in <i>E</i>. The
+<tt>CapacityEdgeMap</tt> argument <tt>cap</tt> must map each edge in
+<i>E</i> to a positive number, and each edge in <i>E<sup>T</sup></i>
+to 0.
+
+<p>
+The algorithm is due to <a
+href="./bibliography.html#edmonds72:_improvements_netflow">Edmonds and
+Karp</a>, though we are using the variation called the ``labeling
+algorithm'' described in <a
+href="./bibliography.html#ahuja93:_network_flows">Network Flows</a>.
+
+<p>
+This algorithm provides a very simple and easy to implement solution to
+the maximum flow problem. However, there are several reasons why this
+algorithm is not as good as the <a
+href="./push_relabel_max_flow.html"><tt>push_relabel_max_flow()</tt></a>
+or the <a
+href="./boykov_kolmogorov_max_flow.html"><tt>boykov_kolmogorov_max_flow()</tt></a>
+algorithm.
+
+<ul>
+  <li>In the non-integer capacity case, the time complexity is <i>O(V
+   E<sup>2</sup>)</i> which is worse than the time complexity of the
+   push-relabel algorithm <i>O(V<sup>2</sup>E<sup>1/2</sup>)</i>
+   for all but the sparsest of graphs.</li>
+
+  <li>In the integer capacity case, if the capacity bound <i>U</i> is
+    very large then the algorithm will take a long time.</li>
+</ul>
+
+
+<H3>Where Defined</H3>
+
+<P>
+<a href="../../../boost/graph/edmonds_karp_max_flow.hpp"><TT>boost/graph/edmonds_karp_max_flow.hpp</TT></a>
+
+<P>
+
+<h3>Parameters</h3>
+
+IN: <tt>Graph&amp; g</tt>
+<blockquote>
+  A directed graph. The
+  graph's type must be a model of <a
+  href="./VertexListGraph.html">VertexListGraph</a> and <a href="./IncidenceGraph.html">IncidenceGraph</a> For each edge
+  <i>(u,v)</i> in the graph, the reverse edge <i>(v,u)</i> must also
+  be in the graph.
+</blockquote>
+
+IN: <tt>vertex_descriptor src</tt>
+<blockquote>
+  The source vertex for the flow network graph.
+</blockquote>
+  
+IN: <tt>vertex_descriptor sink</tt>
+<blockquote>
+  The sink vertex for the flow network graph.
+</blockquote>
+  
+<h3>Named Parameters</h3>
+
+
+IN: <tt>capacity_map(CapacityEdgeMap cap)</tt>
+<blockquote>
+  The edge capacity property map. The type must be a model of a
+  constant <a
+  href="../../property_map/doc/LvaluePropertyMap.html">Lvalue Property Map</a>. The
+  key type of the map must be the graph's edge descriptor type.<br>
+  <b>Default:</b> <tt>get(edge_capacity, g)</tt>
+</blockquote>
+  
+OUT: <tt>residual_capacity_map(ResidualCapacityEdgeMap res)</tt>
+<blockquote>
+  This maps edges to their residual capacity. The type must be a model
+  of a mutable <a
+  href="../../property_map/doc/LvaluePropertyMap.html">Lvalue Property
+  Map</a>. The key type of the map must be the graph's edge descriptor
+  type.<br>
+  <b>Default:</b> <tt>get(edge_residual_capacity, g)</tt>
+</blockquote>
+
+IN: <tt>reverse_edge_map(ReverseEdgeMap rev)</tt>
+<blockquote>
+  An edge property map that maps every edge <i>(u,v)</i> in the graph
+  to the reverse edge <i>(v,u)</i>. The map must be a model of
+  constant <a href="../../property_map/doc/LvaluePropertyMap.html">Lvalue
+  Property Map</a>. The key type of the map must be the graph's edge
+  descriptor type.<br>
+  <b>Default:</b> <tt>get(edge_reverse, g)</tt>
+</blockquote>
+
+UTIL: <tt>color_map(ColorMap color)</tt>
+<blockquote>
+  Used by the algorithm to keep track of progress during the
+  breadth-first search stage. At the end of the algorithm, the white
+  vertices define the minimum cut set. The map must be a model of
+  mutable <a
+  href="../../property_map/doc/LvaluePropertyMap.html">Lvalue Property Map</a>.
+  The key type of the map should be the graph's vertex descriptor type, and
+  the value type must be a model of <a
+  href="./ColorValue.html">ColorValue</a>.<br>
+
+  <b>Default:</b> an <a
+  href="../../property_map/doc/iterator_property_map.html">
+  <tt>iterator_property_map</tt></a> created from a <tt>std::vector</tt>
+  of <tt>default_color_type</tt> of size <tt>num_vertices(g)</tt> and
+  using the <tt>i_map</tt> for the index map.
+</blockquote>
+
+UTIL: <tt>predecessor_map(PredEdgeMap pred)</tt>
+<blockquote>
+  Use by the algorithm to store augmenting paths. The map must be a
+  model of mutable <a
+  href="../../property_map/doc/LvaluePropertyMap.html">Lvalue Property Map</a>.
+  The key type must be the graph's vertex descriptor type and the
+  value type must be the graph's edge descriptor type.<br>
+
+  <b>Default:</b> an <a
+  href="../../property_map/doc/iterator_property_map.html">
+  <tt>iterator_property_map</tt></a> created from a <tt>std::vector</tt>
+  of edge descriptors of size <tt>num_vertices(g)</tt> and
+  using the <tt>i_map</tt> for the index map.
+</blockquote>
+
+IN: <tt>vertex_index_map(VertexIndexMap i_map)</tt>
+<blockquote>
+  Maps each vertex of the graph to a unique integer in the range
+  <tt>[0, num_vertices(g))</tt>. This property map is only needed
+  if the default for the color or predecessor map is used.
+  The vertex index map must be a model of <a
+  href="../../property_map/doc/ReadablePropertyMap.html">Readable Property
+  Map</a>. The key type of the map must be the graph's vertex
+  descriptor type.<br>
+  <b>Default:</b> <tt>get(vertex_index, g)</tt>
+    Note: if you use this default, make sure your graph has
+    an internal <tt>vertex_index</tt> property. For example,
+    <tt>adjacency_list</tt> with <tt>VertexList=listS</tt> does
+    not have an internal <tt>vertex_index</tt> property.
+</blockquote>
+
+
+<h3>Complexity</h3>
+
+The time complexity is <i>O(V E<sup>2</sup>)</i> in the general case
+or <i>O(V E U)</i> if capacity values are integers bounded by
+some constant <i>U</i>.
+
+<h3>Example</h3>
+
+The program in <a
+href="../example/edmonds-karp-eg.cpp"><tt>example/edmonds-karp-eg.cpp</tt></a>
+reads an example maximum flow problem (a graph with edge capacities)
+from a file in the DIMACS format and computes the maximum flow.
+
+
+<h3>See Also</h3>
+
+<a href="./push_relabel_max_flow.html"><tt>push_relabel_max_flow()</tt></a><br>
+<a href="./boykov_kolmogorov_max_flow.html"><tt>boykov_kolmogorov_max_flow()</tt></a>.
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/users/people/jeremy_siek.html">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 
+<!--  LocalWords:  HTML Siek Edmonds BGCOLOR ffffff ee VLINK ALINK ff IMG SRC
+ -->
+<!--  LocalWords:  gif ALT BR sec edmonds karp TT DIV CELLPADDING TR TD PRE lt
+ -->
+<!--  LocalWords:  typename VertexListGraph CapacityEdgeMap ReverseEdgeMap gt
+ -->
+<!--  LocalWords:  ResidualCapacityEdgeMap VertexIndexMap src rev ColorMap pred
+ -->
+<!--  LocalWords:  PredEdgeMap tt href html hpp ul li nbsp br LvaluePropertyMap
+ -->
+<!--  LocalWords:  num ColorValue DIMACS cpp pre config iostream dimacs int std
+ -->
+<!--  LocalWords:  namespace vecS directedS cout endl iter ei HR valign nowrap
+ -->
+<!--  LocalWords:  jeremy siek htm Univ mailto jsiek lsc edu
+p -->

doc/eg1-iso.cpp

@@ -0,0 +1,106 @@
+// Boost.Graph library isomorphism test
+
+// Copyright (C) 2001 Douglas Gregor (gregod@cs.rpi.edu)
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// For more information, see http://www.boost.org
+//
+// Revision History:
+//
+// 29 Nov 2001    Jeremy Siek
+//      Changed to use Boost.Random.
+// 29 Nov 2001    Doug Gregor
+//      Initial checkin.
+
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/isomorphism.hpp>
+//#include "isomorphism-v3.hpp"
+#include <boost/property_map/property_map.hpp>
+#include <iostream>
+#include <fstream>
+#include <map>
+#include <algorithm>
+#include <cstdlib>
+#include <ctime>
+
+using namespace boost;
+
+
+enum { a, b, c, d, e, f, g, h };
+enum { _1, _2, _3, _4, _5, _6, _7, _8 };
+
+void test_isomorphism() 
+{
+  typedef adjacency_list<vecS, vecS, bidirectionalS> GraphA;
+  typedef adjacency_list<vecS, vecS, bidirectionalS> GraphB;
+
+  char a_names[] = "abcdefgh";
+  char b_names[] = "12345678";
+
+  GraphA Ga(8);
+  add_edge(a, d, Ga);
+  add_edge(a, h, Ga);
+  add_edge(b, c, Ga);
+  add_edge(b, e, Ga);
+  add_edge(c, f, Ga);
+  add_edge(d, a, Ga);
+  add_edge(d, h, Ga);
+  add_edge(e, b, Ga);
+  add_edge(f, b, Ga);
+  add_edge(f, e, Ga);
+  add_edge(g, d, Ga);
+  add_edge(g, f, Ga);
+  add_edge(h, c, Ga);
+  add_edge(h, g, Ga);
+
+  GraphB Gb(8);
+  add_edge(_1, _6, Gb);
+  add_edge(_2, _1, Gb);
+  add_edge(_2, _5, Gb);
+  add_edge(_3, _2, Gb);
+  add_edge(_3, _4, Gb);
+  add_edge(_4, _2, Gb);
+  add_edge(_4, _3, Gb);
+  add_edge(_5, _4, Gb);
+  add_edge(_5, _6, Gb);
+  add_edge(_6, _7, Gb);
+  add_edge(_6, _8, Gb);
+  add_edge(_7, _8, Gb);
+  add_edge(_8, _1, Gb);
+  add_edge(_8, _7, Gb);
+  
+
+  std::vector<std::size_t> in_degree_A(num_vertices(Ga));
+  boost::detail::compute_in_degree(Ga, &in_degree_A[0]);
+
+  std::vector<std::size_t> in_degree_B(num_vertices(Gb));
+  boost::detail::compute_in_degree(Gb, &in_degree_B[0]);
+
+  degree_vertex_invariant<std::size_t*, GraphA> 
+    invariantA(&in_degree_A[0], Ga);
+  degree_vertex_invariant<std::size_t*, GraphB> 
+    invariantB(&in_degree_B[0], Gb);
+
+  std::vector<graph_traits<GraphB>::vertex_descriptor> f(num_vertices(Ga));
+
+  bool ret = isomorphism(Ga, Gb, &f[0], invariantA, invariantB, 
+                         (invariantB.max)(),
+                         get(vertex_index, Ga), get(vertex_index, Gb));
+  assert(ret == true);
+
+  for (std::size_t i = 0; i < num_vertices(Ga); ++i)
+    std::cout << "f(" << a_names[i] << ")=" << b_names[f[i]] << std::endl;
+  
+  BOOST_TEST(verify_isomorphism(Ga, Gb, &f[0]));
+}
+
+int test_main(int, char* [])
+{
+  test_isomorphism();
+  return boost::report_errors();
+}

doc/erdos_renyi_generator.html

@@ -0,0 +1,152 @@
+<HTML>
+<!--
+     Copyright (c) 2004, 2005 The Trustees of Indiana University
+    
+     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)
+    
+      Authors: Douglas Gregor
+               Jeremiah Willcock
+               Andrew Lumsdaine
+  -->
+<Head>
+  <Title>Boost Graph Library: Erd&ouml;s-Renyi Generator</Title>
+<script language="JavaScript" type="text/JavaScript">
+<!--
+function address(host, user) {
+        var atchar = '@';
+        var thingy = user+atchar+host;
+        thingy = '<a hre' + 'f=' + "mai" + "lto:" + thingy + '>' + user+atchar+host + '</a>';
+        document.write(thingy);
+}
+//-->
+</script>
+</head>
+
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<tt>erdos_renyi_iterator</tt>
+
+<br>
+
+<PRE>
+template&lt;typename RandomGenerator, typename Graph&gt;
+class erdos_renyi_iterator
+{
+public:
+  typedef std::input_iterator_tag iterator_category;
+  typedef std::pair&lt;vertices_size_type, vertices_size_type&gt; value_type;
+  typedef const value_type&amp; reference;
+  typedef const value_type* pointer;
+  typedef void difference_type;
+
+  erdos_renyi_iterator();
+  erdos_renyi_iterator(RandomGenerator&amp; gen, vertices_size_type n,
+                       double fraction = 0.0, bool allow_self_loops = false);
+  erdos_renyi_iterator(RandomGenerator&amp; gen, vertices_size_type n,
+                       edges_size_type m, bool allow_self_loops = false);
+
+  // Iterator operations
+  reference operator*() const;
+  pointer operator-&gt;() const;
+  erdos_renyi_iterator&amp; operator++();
+  erdos_renyi_iterator operator++(int);
+  bool operator==(const erdos_renyi_iterator&amp; other) const;
+  bool operator!=(const erdos_renyi_iterator&amp; other) const;
+}; 
+</PRE>
+
+<p> This class template implements a generator for Erd&ouml;s-Renyi
+graphs, suitable for initializing an <a
+href="adjacency_list.html"><tt>adjacency_list</tt></a> or other graph
+structure with iterator-based initialization. An Erd&ouml;s-Renyi
+graph <em>G = (n, p)</em> is a graph with <em>n</em> vertices
+that. The probability of having an edge <em>(u, v)</em> in <em>G</em>
+is <em>p</em> for any vertices <em>u</em> and <em>v</em>. Typically,
+there are no self-loops, but the generator can optionally introduce
+self-loops with probability <em>p</em>. This generator will not
+produce any parallel edges and will produce edges in sorted order (as
+required by, e.g., the <a
+href="compressed_sparse_row.html"><tt>compressed_sparse_row_graph</tt></a>).</p>
+
+<p>Erd&ouml;s-Renyi graphs typically exhibit very little
+structure. For this reason, they are rarely useful in modeling
+real-world problems. However, they are often used when determining
+the theoretical complexity of complex graph algorithms.</p>
+
+<p>If you want the possibility of generating parallel edges and don't
+care about sorted order, use the <a
+href="erdos_renyi_generator.html"><tt>erdos_renyi_iterator</tt></a>.</p>
+
+<h3>Where Defined</h3>
+
+<a href="../../../boost/graph/erdos_renyi_generator.hpp"><tt>boost/graph/erdos_renyi_generator.hpp</tt></a>
+
+<h3>Constructors</h3>
+
+<a name="default-constructor"/>
+<pre>erdos_renyi_iterator();</pre>
+<blockquote>
+Constructs a past-the-end iterator.
+</blockquote>
+
+<pre>
+erdos_renyi_iterator(RandomGenerator&amp; gen, vertices_size_type n,
+                     double fraction = 0.0, bool allow_self_loops = false);
+</pre>
+<blockquote>
+Constructs an Erd&ouml;s-Renyi generator iterator that creates a
+graph with <tt>n</tt> vertices and a given <tt>fraction</tt> of the
+total number of edges that a simple graph may have.
+<tt>probability</tt>. Random vertices and edges are selected using the
+random number generator <tt>gen</tt>. Self-loops are permitted only when
+<tt>allow_self_loops</tt> is <tt>true</tt>.
+</blockquote>
+
+<pre>
+erdos_renyi_iterator(RandomGenerator&amp; gen, vertices_size_type n,
+                     edges_size_type m, bool allow_self_loops = false);
+</pre>
+<blockquote>
+Constructs an Erd&ouml;s-Renyi generator iterator that creates a
+graph with <tt>n</tt> vertices and <tt>m</tt> edges.
+<tt>probability</tt>. Random vertices and edges are selected using the
+random number generator <tt>gen</tt>. Self-loops are permitted only when
+<tt>allow_self_loops</tt> is <tt>true</tt>.
+</blockquote>
+
+<H3>Example</H3>
+
+<pre>
+#include &lt;boost/graph/adjacency_list.hpp&gt;
+#include &lt;boost/graph/erdos_renyi_generator.hpp&gt;
+#include &lt;boost/random/linear_congruential.hpp&gt;
+
+typedef boost::adjacency_list&lt;&gt; Graph;
+typedef boost::erdos_renyi_iterator&lt;boost::minstd_rand, Graph&gt; ERGen;
+
+int main()
+{
+  boost::minstd_rand gen;
+  // Create graph with 100 nodes and edges with probability 0.05
+  Graph g(ERGen(gen, 100, 0.05), ERGen(), 100);
+  return 0;
+}
+</pre>
+
+<br>
+<HR>
+<TABLE>
+<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="https://homes.cs.washington.edu/~al75">Andrew Lumsdaine</A>,
+Indiana University (<script language="Javascript">address("osl.iu.edu", "lums")</script>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 

doc/exception.html

@@ -0,0 +1,46 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek 2002
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Exceptions</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<h1><a href="../../../boost/graph/exception.hpp"><tt>boost/graph/exception.hpp</tt></a></h1>
+
+<P>
+The BGL defines several exception classes for reporting errors from
+BGL algorithms. Many of the BGL algorithms place certain requirements
+on the input graph. If these requirements are not met then the
+algorithm can not successfully complete, and instead throws the
+appropriate exception.
+</P>
+
+<h3>Synopsis</h3>
+
+<pre>
+  struct <a name="bad_graph">bad_graph</a> : public invalid_argument {
+    bad_graph(const string& what_arg);
+  };
+  struct <a name="not_a_dag">not_a_dag</a> : public bad_graph {
+    not_a_dag();
+  };
+  struct <a name="negative_edge">negative_edge</a> : public bad_graph {
+    negative_edge();
+  };
+  struct <a name="negative_cycle">negative_cycle</a> : public bad_graph {
+    negative_cycle();
+  };
+  struct <a name="not_connected">not_connected</a> : public bad_graph {
+    not_connected();
+  };
+</pre>

doc/faq.html

@@ -0,0 +1,152 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: FAQ</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<h1>Frequently Asked Questions</h1>
+
+<ol>
+
+<li>
+How do I perform an early exit from an algorithm such as BFS?<br>
+
+<p>
+Create a visitor that throws an exception when you want to cut off the
+search, then put your call to <tt>breadth_first_search</tt> inside of
+an appropriate try/catch block. This strikes many programmers as a
+misuse of exceptions, however, much thought was put into the decision
+to have exceptions has the preferred way to exit early. See boost
+email discussions for more details.
+</p>
+
+<li>
+Why is the visitor parameter passed by value rather than reference
+in the various BGL algorithms?<br>
+
+<p>
+One of the usage scenarios that we wanted to support with the
+algorithms was creating visitor objects on the fly, within the
+argument list of the call to the graph algorithm. In this situation,
+the visitor object is a temporary object. Now there is a truly
+unfortunate rule in the C++ standard that says a temporary cannot be
+bound to a non-const reference parameter.  So we had to decide whether
+we wanted to support this kind of usage and call-by-value, or not and
+call-by-reference. We chose call-by-value, following in the footsteps
+of the STL (which passes functors by value).  The disadvantage of this
+decision is that if your visitor contains state and changes that state
+during the algorithm, the change will be made to a copy of the visitor
+object, not the visitor object passed in. Therefore you may want the
+visitor to hold this state by pointer or reference.
+</p>
+
+<li>Why does the BGL interface use friend functions (or free functions)
+  instead of member functions?<br>
+<p>
+For the most part, the differences between member functions and free
+functions are syntactic, and not very important, though people can get
+religious about them. However, we had one technical reason for
+favoring free functions. A programmer can overload a free function for
+a type coming from a 3rd party without modifying the source
+code/definition of that type. There are several uses of this in the
+BGL. For example, Stanford GraphBase and LEDA graphs can both be used
+in BGL algorithms because of overloads in <tt>stanford_graph.hpp</tt>
+and <tt>leda_graph.hpp</tt>. One can even use
+<tt>std::vector&lt;std::list&gt;</tt> as a graph due to the overloads
+in <tt>vector_as_graph.hpp</tt>.
+</p>
+<p>
+Of course, there is a way to adapt 3rd party classes into an interface
+with member functions. You create an adaptor class. However, the
+disadvantage of an adaptor class (compared to overloaded functions) is
+that one has to physically wrap and unwrap the objects as they go
+into/out of BGL algorithms. So the overloaded function route is more
+convenient.  Granted, this is not a huge difference, but since there
+weren't other strong reasons, it was enough for us to choose free
+functions.
+</p>
+ 
+<p> 
+Our religious reason for choosing free functions is to send the message
+that BGL is a generic library, and not a traditional object-oriented
+library. OO was hip in the 80s and 90s, but its time we moved beyond!
+</p>
+</li>
+
+
+
+
+<li>How do I create a graph where the edges are sorted/ordered? <br>
+  <p>The example <a href="../example/ordered_out_edges.cpp">
+  <tt>ordered_out_edges.cpp</tt></a> shows how to do this.</p>
+  </li>
+
+<li>Why does the algorithm X work with <tt>adjacency_list</tt> where
+ <tt>VertexList=vecS</tt> but not when <tt>VertexList=listS</tt>? <br><br>
+ Often the reason is that the algorithm expects to find the
+ <tt>vertex_index</tt> property stored in the graph. When
+ <tt>VertexList=vecS</tt>, the <tt>adjacency_list</tt> automatically
+ has a <tt>vertex_index</tt> property. However, when <tt>VertexList=listS</tt>
+ this is not the case, and the <tt>vertex_index</tt> property must be
+ explicitly added, and initialized. For example,
+<pre>
+  // specify the graph type
+  typedef adjacency_list&lt;listS, listS, undirectedS,
+                         property&lt;vertex_index_t, std::size_t&gt;,
+                         no_property
+                        &gt; graph_t;
+
+  // construct a graph object
+  graph_t G(num_nodes);
+  // obtain a property map for the vertex_index property
+  property_map&lt;graph_t, vertex_index_t&gt;::type
+    index = get(vertex_index, G);
+  // initialize the vertex_index property values
+  graph_traits&lt;graph_t&gt;::vertex_iterator vi, vend;
+  graph_traits&lt;graph_t&gt;::vertices_size_type cnt = 0;
+  for(boost::tie(vi,vend) = vertices(G); vi != vend; ++vi)
+    put(index, *vi, cnt++);
+</pre>
+</li>
+
+<li>When using algorithm X, why do I get an error about a property
+not being found, such as:
+<pre>
+../../../boost/concept_check.hpp:209: no match for
+`boost::detail::error_property_not_found &amp; == 
+ boost::detail::error_property_not_found &amp;'
+</pre>
+or a message such as:
+<pre>
+../../..\boost/graph/depth_first_search.hpp(78) : error C2664: 'white'
+: cannot convert parameter 1 from 
+ 'struct boost::detail::error_property_not_found'
+ to 'enum boost::default_color_type'
+</pre>
+
+The reason is that the algorithm expected to find some property (like color or
+weight) attached to the vertices or edges of the graph, but didn't
+find it. You need to either add an interior property to the graph, or
+create an exterior property map for the property and pass it as an
+argument to the algorithm.</li>
+
+
+
+</ol>
+<!--  LocalWords:  gif ALT BGL std const STL GraphBase LEDA BFS stanford hpp OO
+ -->
+<!--  LocalWords:  leda cpp VertexList vecS listS undirectedS num cnt struct
+ -->
+<!--  LocalWords:  enum
+ -->

doc/figs/Makefile

@@ -1,4 +1,9 @@
 # -*- makefile -*-
+# Copyright (c) 2002 Trustees of Indiana University
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
 
 .SUFFIXES:  .fig .gif .tif .jpeg