Merge pull request #518 from boostorg/develop

Fixes to documentation.

.clang-format

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

.drone.star

@@ -0,0 +1,49 @@
+# Use, modification, and distribution are
+# subject to the Boost Software License, Version 1.0. (See accompanying
+# file LICENSE.txt)
+#
+# Copyright Rene Rivera 2020.
+
+# For Drone CI we use the Starlark scripting language to reduce duplication.
+# As the yaml syntax for Drone CI is rather limited.
+#
+#
+globalenv={'ADD_UBUNTU_TOOLCHAIN_PPA': 'true'}
+linuxglobalimage="cppalliance/droneubuntu1604:1"
+windowsglobalimage="cppalliance/dronevs2019"
+
+def main(ctx):
+  return [
+  linux_cxx("g++-7 14", "g++-7", packages="g++-7", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-7', 'CXXSTD': '14', }, globalenv=globalenv),
+  linux_cxx("g++-7 17", "g++-7", packages="g++-7", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-7', 'CXXSTD': '17', }, globalenv=globalenv),
+
+  linux_cxx("g++-8 14", "g++-8", packages="g++-8", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': '14', }, globalenv=globalenv),
+  linux_cxx("g++-8 17", "g++-8", packages="g++-8", buildtype="boost", image=linuxglobalimage, environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-8', 'CXXSTD': '17', }, globalenv=globalenv),
+
+  linux_cxx("g++-9 14", "g++-9", packages="g++-9", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': '14', }, globalenv=globalenv),
+  linux_cxx("g++-9 17", "g++-9", packages="g++-9", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': '17', }, globalenv=globalenv),
+  linux_cxx("g++-9 2a", "g++-9", packages="g++-9", buildtype="boost", image="cppalliance/droneubuntu1404:1", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-9', 'CXXSTD': '2a', }, globalenv=globalenv),
+
+  linux_cxx("g++-10 14", "g++-10", packages="g++-10", image="cppalliance/droneubuntu2004:1", buildtype="boost", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': '14', }, globalenv=globalenv),
+  linux_cxx("g++-10 17", "g++-10", packages="g++-10", image="cppalliance/droneubuntu2004:1", buildtype="boost", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': '17', }, globalenv=globalenv),
+  linux_cxx("g++-10 20", "g++-10", packages="g++-10", image="cppalliance/droneubuntu2004:1", buildtype="boost", environment={'TOOLSET': 'gcc', 'COMPILER': 'g++-10', 'CXXSTD': '20', }, globalenv=globalenv),
+  
+  linux_cxx("clang++-7 14", "clang++-7", packages="clang-7", llvm_os="xenial", llvm_ver="7", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-7', 'CXXSTD': '14', }, globalenv=globalenv),
+  linux_cxx("clang++-7 17", "clang++-7", packages="clang-7", llvm_os="xenial", llvm_ver="7", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-7', 'CXXSTD': '17', }, globalenv=globalenv),
+  
+  linux_cxx("clang++-8 14", "clang++-8", packages="clang-8", llvm_os="xenial", llvm_ver="8", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-8', 'CXXSTD': '14', }, globalenv=globalenv),
+  linux_cxx("clang++-8 17", "clang++-8", packages="clang-8", llvm_os="xenial", llvm_ver="8", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-8', 'CXXSTD': '17', }, globalenv=globalenv),
+
+  linux_cxx("clang++-9 14", "clang++-9", packages="clang-9", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': '14', }, globalenv=globalenv),
+  linux_cxx("clang++-9 17", "clang++-9", packages="clang-9", llvm_os="xenial", llvm_ver="9", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-9', 'CXXSTD': '17', }, globalenv=globalenv),
+
+  linux_cxx("clang++-10 14", "clang++-10", packages="clang-10", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': '14', }, globalenv=globalenv),
+  linux_cxx("clang++-10 17", "clang++-10", packages="clang-10", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': '17', }, globalenv=globalenv),
+  linux_cxx("clang++-10 20", "clang++-10", packages="clang-10", llvm_os="xenial", llvm_ver="10", buildtype="boost", image="cppalliance/droneubuntu1804:1", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++-10', 'CXXSTD': '20', }, globalenv=globalenv),
+
+  osx_cxx("XCode-11.7 14", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '14', }, globalenv=globalenv),
+  osx_cxx("XCode-11.7 17", "clang++", packages="", buildtype="boost", xcode_version="11.7", environment={'TOOLSET': 'clang', 'COMPILER': 'clang++', 'CXXSTD': '17', }, globalenv=globalenv),
+  ]
+
+# from https://github.com/boostorg/boost-ci
+load("@boost_ci//ci/drone/:functions.star", "linux_cxx","windows_cxx","osx_cxx","freebsd_cxx")

.drone/after-success.sh

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

.drone/before-install.sh

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

.drone/before-script.sh

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

.drone/boost.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+
+set -ex
+export TRAVIS_BUILD_DIR=$(pwd)
+export DRONE_BUILD_DIR=$(pwd)
+export TRAVIS_BRANCH=$DRONE_BRANCH
+export VCS_COMMIT_ID=$DRONE_COMMIT
+export GIT_COMMIT=$DRONE_COMMIT
+export PATH=~/.local/bin:/usr/local/bin:$PATH
+
+echo '==================================> BEFORE_INSTALL'
+
+. .drone/before-install.sh
+
+echo '==================================> INSTALL'
+
+cd ..
+git clone -b $TRAVIS_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+cd boost-root
+git submodule update --init tools/build
+git submodule update --init libs/config
+git submodule update --init tools/boost_install
+git submodule update --init libs/headers
+git submodule update --init tools/boostdep
+cp -r $TRAVIS_BUILD_DIR/* libs/graph
+python tools/boostdep/depinst/depinst.py graph
+./bootstrap.sh
+./b2 headers
+
+echo '==================================> BEFORE_SCRIPT'
+
+. $DRONE_BUILD_DIR/.drone/before-script.sh
+
+echo '==================================> SCRIPT'
+
+echo "using $TOOLSET : : $COMPILER : $OPTIONS ;" > ~/user-config.jam
+(cd libs/config/test && ../../../b2 cxxstd=$CXXSTD config_info_travis_install toolset=$TOOLSET && ./config_info_travis)
+(cd libs/graph/test && ../../../b2 -j3 cxxstd=$CXXSTD toolset=$TOOLSET define=CI_SUPPRESS_KNOWN_ISSUES)
+
+echo '==================================> AFTER_SUCCESS'
+
+. $DRONE_BUILD_DIR/.drone/after-success.sh

.drone/drone.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+
+set -ex
+export TRAVIS_BUILD_DIR=$(pwd)
+export DRONE_BUILD_DIR=$(pwd)
+export TRAVIS_BRANCH=$DRONE_BRANCH
+export VCS_COMMIT_ID=$DRONE_COMMIT
+export GIT_COMMIT=$DRONE_COMMIT
+export PATH=~/.local/bin:/usr/local/bin:$PATH
+
+echo '==================================> BEFORE_INSTALL'
+
+. .drone/before-install.sh
+
+echo '==================================> INSTALL'
+
+cd ..
+git clone -b $TRAVIS_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+cd boost-root
+git submodule update --init tools/build
+git submodule update --init libs/config
+git submodule update --init tools/boost_install
+git submodule update --init libs/headers
+git submodule update --init tools/boostdep
+cp -r $TRAVIS_BUILD_DIR/* libs/graph
+python tools/boostdep/depinst/depinst.py graph
+./bootstrap.sh
+./b2 headers
+
+echo '==================================> BEFORE_SCRIPT'
+
+. $DRONE_BUILD_DIR/.drone/before-script.sh
+
+echo '==================================> SCRIPT'
+
+echo "using $TOOLSET : : $COMPILER : $OPTIONS ;" > ~/user-config.jam
+(cd libs/config/test && ../../../b2 cxxstd=$CXXSTD config_info_travis_install toolset=$TOOLSET && ./config_info_travis)
+(cd libs/graph/test && ../../../b2 -j3 cxxstd=$CXXSTD toolset=$TOOLSET define=CI_SUPPRESS_KNOWN_ISSUES)
+
+echo '==================================> AFTER_SUCCESS'
+
+. $DRONE_BUILD_DIR/.drone/after-success.sh

.github/CODEOWNERS

@@ -0,0 +1,19 @@
+# Code owners for Boost.Graph
+#
+# When a PR is opened, GitHub automatically requests review from the matching
+# owners listed below. The order of rules matters: later, more specific rules
+# override earlier, more general ones.
+#
+# Authoritative maintainer list: meta/libraries.json
+# Contact details: CONTRIBUTING.md#maintainers
+
+# Default reviewers for everything
+*                       @jeremy-murphy @becheler
+
+# Documentation, contributor-facing files, and CI configuration
+/doc/                   @becheler
+/README.md              @becheler
+/CONTRIBUTING.md        @becheler
+/SECURITY.md            @becheler
+/CODE_OF_CONDUCT.md     @becheler
+/.github/               @becheler

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,84 @@
+---
+name: Bug report
+about: Report a defect or unexpected behavior in Boost.Graph
+title: ''
+labels: ''
+type: Bug
+assignees: ''
+---
+
+<!--
+Thank you for taking the time to file a bug report. Please fill in as much
+of the template below as you can. Reports without a reproducer or
+environment details are very hard to triage.
+-->
+
+### Before filing
+
+- [ ] I searched the [existing issues](https://github.com/boostorg/graph/issues?q=is%3Aissue) and did not find a duplicate.
+- [ ] I have reproduced the bug against the `develop` branch or the latest Boost release.
+- [ ] I have a minimal reproducer (or I will paste my full failing code below).
+
+### Boost version
+
+<!--
+You can find the version number in `<boost/version.hpp>`, or by running
+`git log -1` in your local Boost.Graph checkout.
+-->
+
+### Compiler family
+
+- [ ] GCC / g++
+- [ ] Clang / clang++
+- [ ] MSVC (Visual Studio)
+- [ ] Intel / oneAPI
+- [ ] Other (specify below)
+
+Exact compiler version: <!-- e.g. g++ 13.2.0, clang 17.0.6, MSVC 19.39 -->
+
+### Standard library
+
+- [ ] libstdc++
+- [ ] libc++
+- [ ] MSVC STL
+- [ ] Other (specify below)
+
+### Operating system
+
+- [ ] Linux
+- [ ] macOS
+- [ ] Windows
+- [ ] Other (specify below)
+
+### Kind of component affected
+
+- [ ] Graph data structure (e.g. `adjacency_list`, `adjacency_matrix`)
+- [ ] Algorithm (e.g. `dijkstra_shortest_paths`, `breadth_first_search`)
+- [ ] Property map
+- [ ] I/O or file-format reader (e.g. `read_graphml`, `read_graphviz`)
+- [ ] Visitor / event hooks
+- [ ] Other (specify below)
+
+Exact name of the affected component: <!-- e.g. dijkstra_shortest_paths -->
+
+### Steps to reproduce
+
+<!--
+A minimal compiling program that demonstrates the problem is ideal.
+A [Compiler Explorer](https://godbolt.org/z/9Esszr9Ga) link is even better.
+-->
+
+### Expected behavior
+
+### Actual behavior
+
+<!--
+Include compiler error messages or runtime output verbatim, with file and
+line numbers where applicable.
+-->
+
+### Are you willing to help?
+
+- [ ] I'd like to submit a fix as a pull request.
+- [ ] I can help diagnose or test a candidate fix.
+- [ ] I'm only reporting the issue.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,9 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Design discussion or open-ended question
+    url: https://github.com/boostorg/graph/discussions
+    about: |
+      For "should we...?" questions, design exploration, or anything not
+      yet a concrete proposal, please start a GitHub Discussion. Issues
+      are reserved for bugs, feature requests with a concrete proposal,
+      and documentation problems.

.github/ISSUE_TEMPLATE/documentation.md

@@ -0,0 +1,59 @@
+---
+name: Documentation issue
+about: Report missing, incorrect, or unclear documentation
+title: ''
+labels: docs
+type: Task
+assignees: ''
+---
+
+<!--
+Documentation problems are real issues. Thanks for taking the time to
+report one.
+-->
+
+### Before filing
+
+- [ ] I searched the [existing issues](https://github.com/boostorg/graph/issues?q=is%3Aissue+label%3Adocs) and did not find a duplicate.
+- [ ] I checked the latest version of the documentation on `develop`.
+
+### Kind of problem
+
+- [ ] Documentation is missing entirely
+- [ ] Documentation is incorrect or out of date
+- [ ] Explanation is unclear or confusing
+- [ ] Example does not compile
+- [ ] Example compiles but does not produce the documented result
+- [ ] Dead link or broken cross-reference
+- [ ] Other (specify below)
+
+### Where is the issue?
+
+<!--
+A link to the page, or the path to the file (for example,
+`doc/quick_tour.html` or `include/boost/graph/dijkstra_shortest_paths.hpp`).
+-->
+
+### What is wrong, missing, or unclear?
+
+<!--
+For example: an example does not compile, an algorithm's complexity is
+not stated, a parameter is undocumented, an explanation is confusing.
+-->
+
+### What did you expect to find?
+
+<!-- What information would have helped you? -->
+
+### Suggested wording (optional)
+
+<!--
+If you already have an idea of what the docs should say, paste a draft
+here.
+-->
+
+### Are you willing to help?
+
+- [ ] I'd like to submit a docs pull request.
+- [ ] I can review a candidate fix.
+- [ ] I'm only reporting the issue.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,72 @@
+---
+name: Feature request
+about: Suggest a new algorithm, API addition, or enhancement
+title: ''
+labels: ''
+type: Feature
+assignees: ''
+---
+
+<!--
+Thanks for proposing an addition to Boost.Graph.
+
+If you want to explore an idea or discuss whether a feature would be
+worthwhile before committing to a concrete proposal, please start a
+GitHub Discussion instead:
+https://github.com/boostorg/graph/discussions
+
+This template is for requests with a clear, actionable proposal: a
+specific algorithm, API, or enhancement that a maintainer could
+reasonably implement or review.
+-->
+
+### Before filing
+
+- [ ] I searched the [existing issues](https://github.com/boostorg/graph/issues?q=is%3Aissue) and did not find a duplicate.
+- [ ] This is a concrete proposal, not an open-ended design question.
+
+### Kind of addition
+
+- [ ] New algorithm
+- [ ] New data structure
+- [ ] New property map or utility
+- [ ] New I/O format reader or writer
+- [ ] Extension to an existing component
+- [ ] Performance improvement
+- [ ] Other (specify below)
+
+### Motivation
+
+<!--
+What problem does this feature solve? Who would use it, and in what
+context?
+-->
+
+### Proposed addition
+
+<!--
+A new algorithm, a new data structure, an extension to an existing
+component, or something else? If you have a rough API sketch, paste it
+here.
+-->
+
+### Relation to existing Boost.Graph components
+
+<!--
+Does this overlap with or build on something that already exists in the
+library (for example, an existing algorithm or property map)?
+-->
+
+### Prior art
+
+- [ ] Reference paper or textbook (cite below)
+- [ ] Implementation in another library (link below)
+- [ ] None / original idea
+
+References: <!-- paste DOI, ISBN, or URL -->
+
+### Are you willing to contribute?
+
+- [ ] I'd like to submit the implementation as a pull request.
+- [ ] I can help with review or testing, but not the implementation.
+- [ ] I'm only proposing the idea.

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,50 @@
+<!--
+Thanks for contributing to Boost.Graph! A few notes before you fill this in:
+
+* Target the `develop` branch.
+* New contributions must be licensed under the
+  [Boost Software License 1.0](https://www.boost.org/LICENSE_1_0.txt).
+* Please link any related issue with `Fixes #N` or `Refs #N`.
+-->
+
+### Before submitting
+
+- [ ] This PR targets the `develop` branch.
+- [ ] I searched for an existing PR or issue covering the same change.
+- [ ] My contribution is licensed under the Boost Software License 1.0.
+
+### Type of change
+
+- [ ] Bug fix
+- [ ] New feature or API addition
+- [ ] Refactor (no behavior change)
+- [ ] Documentation
+- [ ] Build, CI, or tooling
+- [ ] Other (specify below)
+
+### Does this PR introduce a breaking change?
+
+- [ ] Yes (describe migration impact below)
+- [ ] No
+
+### What this PR does
+
+<!-- A short summary of the change. -->
+
+### Motivation
+
+<!-- Why is this needed? Link related issue with `Fixes #N` or `Refs #N`. -->
+
+### Testing
+
+<!--
+How did you verify the change? Which compilers and standard libraries did
+you build against? Were new tests added under `test/`?
+-->
+
+### Checklist
+
+- [ ] Existing tests pass (`b2` in the `test/` directory).
+- [ ] New behavior is covered by a test, or this is a docs / build / refactor change.
+- [ ] Documentation was updated if user-facing behavior changed.
+- [ ] No new compiler warnings on the platforms I built against.

.github/scripts/warn_table.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+"""Print a markdown table comparing compiler-warning counts between two CI log archives.
+
+Usage: warn_table.py BASELINE.zip AFTER.zip
+
+A warning is a line matching 'file:line:col: warning:' (clang/gcc) or 'warning Cxxxx'
+(msvc). Linker, "N warnings generated" summary, and CI-runner lines are not counted.
+"""
+import re
+import sys
+import zipfile
+
+WARNING = re.compile(r":\d+:\d+: warning:|warning C\d+")
+
+
+def counts(zip_path):
+    """Map each CI job to its warning count, read from the run's log archive."""
+    result = {}
+    with zipfile.ZipFile(zip_path) as archive:
+        for entry in archive.namelist():
+            # Top-level per-job logs are named like "12_ubuntu (gcc-14, 14).txt".
+            if "/" in entry or not entry.endswith(".txt"):
+                continue
+            job = re.sub(r"^\d+_", "", entry[:-4])
+            log = archive.read(entry).decode("utf-8", "replace")
+            result[job] = sum(1 for line in log.splitlines() if WARNING.search(line))
+    return result
+
+
+def main(baseline_zip, after_zip):
+    baseline = counts(baseline_zip)
+    after = counts(after_zip)
+    print("| Job | Baseline | After | Delta |")
+    print("|-----|---------:|------:|------:|")
+    for job in sorted(baseline.keys() | after.keys()):
+        if "cmake" in job:  # cmake jobs build only the library, they never warn
+            continue
+        before = baseline.get(job, 0)
+        now = after.get(job, 0)
+        diff = now - before
+        delta = f"{diff:+d}" if diff else "0"
+        print(f"| {job} | {before} | {now} | {delta} |")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 3:
+        sys.exit("usage: warn_table.py BASELINE.zip AFTER.zip")
+    main(sys.argv[1], sys.argv[2])

.github/workflows/ci.yml

@@ -0,0 +1,357 @@
+# Copyright 2020 Evan Miller
+# Copyright 2020 Matt Borland
+# Copyright 2021 John 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)
+
+name: CI
+on: [ push, pull_request ]
+jobs:
+  ubuntu:
+    runs-on: ubuntu-24.04
+    strategy:
+      fail-fast: false
+      matrix:
+        compiler: [ gcc-14, clang-19 ]
+        cxxstd: [ 14, 17, 20, 23 ]
+    steps:
+      - uses: actions/checkout@master
+        with:
+          fetch-depth: '0'
+      - uses: mstachniuk/ci-skip@v1
+        with:
+          commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[windows];[Windows];[WINDOWS];[apple];[Apple];[APPLE]'
+          commit-filter-separator: ';'
+          fail-fast: true
+      - name: Set ENV
+        run: |
+          echo ${{ matrix.compiler }} | awk '/^gcc/ { print "TOOLSET=gcc" } /^clang/ { print "TOOLSET=clang" }' >> $GITHUB_ENV
+          echo ${{ matrix.compiler }} | awk '/^gcc/ { gsub(/gcc/,"CXX=g++"); print; } /^clang/ { gsub(/clang/,"CXX=clang++"); print; }' >> $GITHUB_ENV
+      - name: Install packages
+        run: sudo apt install ${{ matrix.compiler }}
+      - name: Checkout main boost
+        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
+      - name: Update tools/boostdep
+        run: git submodule update --init tools/boostdep
+        working-directory: ../boost-root
+      - name: Copy files
+        run: cp -r $GITHUB_WORKSPACE/* libs/graph
+        working-directory: ../boost-root
+      - name: Install deps
+        run: python tools/boostdep/depinst/depinst.py graph
+        working-directory: ../boost-root
+      - name: Bootstrap
+        run: ./bootstrap.sh
+        working-directory: ../boost-root
+      - name: Generate headers
+        run: ./b2 headers
+        working-directory: ../boost-root
+      - name: Generate user config
+        run: 'echo "using $TOOLSET : : $CXX ;" > ~/user-config.jam'
+        working-directory: ../boost-root
+      - name: Config info
+        run: ../../../b2 print_config_info toolset=$TOOLSET cxxstd=${{ matrix.cxxstd }}
+        working-directory: ../boost-root/libs/config/test
+      - name: Test
+        run: ../../../b2 toolset=$TOOLSET cxxstd=${{ matrix.cxxstd }}
+        working-directory: ../boost-root/libs/graph/test
+  macos:
+    runs-on: macos-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        toolset: [ clang ]
+        cxxstd: [ 14, 17, 20 ]
+    steps:
+      - uses: actions/checkout@master
+        with:
+          fetch-depth: '0'
+      - uses: mstachniuk/ci-skip@v1
+        with:
+          commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[windows];[Windows];[WINDOWS];[linux];[Linux];[LINUX]'
+          commit-filter-separator: ';'
+          fail-fast: true
+      - name: Checkout main boost
+        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
+      - name: Update tools/boostdep
+        run: git submodule update --init tools/boostdep
+        working-directory: ../boost-root
+      - name: Copy files
+        run: cp -r $GITHUB_WORKSPACE/* libs/graph
+        working-directory: ../boost-root
+      - name: Install deps
+        run: python tools/boostdep/depinst/depinst.py graph
+        working-directory: ../boost-root
+      - name: Bootstrap
+        run: ./bootstrap.sh
+        working-directory: ../boost-root
+      - name: Generate headers
+        run: ./b2 headers
+        working-directory: ../boost-root
+      - name: Config info
+        run: ../../../b2 print_config_info toolset=${{ matrix.toolset }} cxxstd=${{ matrix.cxxstd }}
+        working-directory: ../boost-root/libs/config/test
+      - name: Test
+        run: ../../../b2 toolset=${{ matrix.toolset }} cxxstd=${{ matrix.cxxstd }} define=CI_SUPPRESS_KNOWN_ISSUES
+        working-directory: ../boost-root/libs/graph/test
+  windows_msvc_14_3:
+    runs-on: windows-2022
+    defaults:
+      run:
+        shell: cmd
+    strategy:
+      fail-fast: false
+      matrix:
+        toolset: [ msvc-14.3 ]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: '0'
+      - uses: mstachniuk/ci-skip@v1
+        with:
+          commit-filter: '[skip ci];[ci skip];[CI SKIP];[SKIP CI];***CI SKIP***;***SKIP CI***;[apple];[Apple];[APPLE];[linux];[Linux];[LINUX]'
+          commit-filter-separator: ';'
+          fail-fast: true
+      - name: Checkout main boost
+        run: git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
+      - name: Update tools/boostdep
+        run: git submodule update --init tools/boostdep
+        working-directory: ../boost-root
+      - name: Copy files
+        run: xcopy /s /e /q %GITHUB_WORKSPACE% libs\graph
+        working-directory: ../boost-root
+      - name: Install deps
+        run: python tools/boostdep/depinst/depinst.py graph
+        working-directory: ../boost-root
+      - name: Bootstrap
+        run: bootstrap
+        working-directory: ../boost-root
+      - name: Generate headers
+        run: b2 headers
+        working-directory: ../boost-root
+      - name: Config info
+        run: ..\..\..\b2 print_config_info cxxstd=14,17,20 address-model=64 toolset=msvc-14.3
+        working-directory: ../boost-root/libs/config/test
+      - name: Test
+        run: ..\..\..\b2 --hash address-model=64 cxxstd=14,17,20 toolset=msvc-14.3
+        working-directory: ../boost-root/libs/graph/test
+
+  posix-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-22.04
+          - os: ubuntu-24.04
+          - os: macos-14
+          - os: macos-15
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Use library with add_subdirectory
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  posix-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-22.04
+          - os: ubuntu-24.04
+          - os: macos-14
+          - os: macos-15
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt-get -y install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Configure
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DCMAKE_INSTALL_PREFIX=~/.local ..
+
+      - name: Install
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install
+
+      - name: Use the installed library
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  windows-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2022
+          - os: windows-2025
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Use library with add_subdirectory (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use library with add_subdirectory (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_subdir_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release
+
+  windows-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-2022
+          - os: windows-2025
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Boost
+        shell: cmd
+        run: |
+          echo GITHUB_REPOSITORY: %GITHUB_REPOSITORY%
+          for /f %%i in ("%GITHUB_REPOSITORY%") do set LIBRARY=%%~nxi
+          echo LIBRARY: %LIBRARY%
+          echo LIBRARY=%LIBRARY%>>%GITHUB_ENV%
+          echo GITHUB_BASE_REF: %GITHUB_BASE_REF%
+          echo GITHUB_REF: %GITHUB_REF%
+          if "%GITHUB_BASE_REF%" == "" set GITHUB_BASE_REF=%GITHUB_REF%
+          set BOOST_BRANCH=develop
+          for /f %%i in ("%GITHUB_BASE_REF%") do if "%%~nxi" == "master" set BOOST_BRANCH=master
+          echo BOOST_BRANCH: %BOOST_BRANCH%
+          cd ..
+          git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          xcopy /s /e /q %GITHUB_WORKSPACE% libs\%LIBRARY%\
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" %LIBRARY%
+
+      - name: Configure
+        shell: cmd
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=%LIBRARY% -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+
+      - name: Install (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install --config Debug
+
+      - name: Install (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install --config Release
+
+      - name: Use the installed library (Debug)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+          cmake --build . --config Debug
+          ctest --output-on-failure --no-tests=error -C Debug
+
+      - name: Use the installed library (Release)
+        shell: cmd
+        run: |
+          cd ../boost-root/libs/%LIBRARY%/test/cmake_install_test/__build__
+          cmake --build . --config Release
+          ctest --output-on-failure --no-tests=error -C Release

.github/workflows/docs.yml

@@ -0,0 +1,62 @@
+name: docs-check
+
+# PR-time sanity check for the Antora documentation:
+#   - b2 builds every example .cpp and regenerates its .txt sidecar
+#     (catches broken examples; failures here fail the job)
+#   - Antora renders the full site (catches broken .adoc, missing
+#     includes, broken xrefs)
+#
+# No deployment. The real publishing path is boostorg/release-tools,
+# which auto-detects doc/build_antora.sh and ships to
+# www.boost.org/doc/libs/<version>/libs/graph/.
+
+on:
+  pull_request:
+    branches: ["develop", "documentation"]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  docs-check:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install Node 20
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      # Set up boost-root so b2 can build the example .cpp files (needs
+      # the full Boost build tree, not just the headers we ship in this
+      # repo).
+      - name: Set up boost-root
+        run: |
+          git clone -b develop --depth 1 https://github.com/boostorg/boost.git ../boost-root
+          cd ../boost-root
+          git submodule update --init tools/boostdep
+          rm -rf libs/graph
+          cp -r "$GITHUB_WORKSPACE" libs/graph
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" graph
+          git submodule update --init --depth 1 libs/static_assert
+          ./bootstrap.sh
+          ./b2 headers
+
+      - name: Snapshot example outputs (b2)
+        working-directory: ../boost-root
+        run: ./b2 -j$(nproc) libs/graph/doc/modules/ROOT/examples
+
+      # Mirror the regenerated .txt sidecars back into the workspace so
+      # the Antora build below renders pages against fresh outputs.
+      - name: Mirror generated .txt back to workspace
+        run: rsync -a ../boost-root/libs/graph/doc/modules/ROOT/examples/ doc/modules/ROOT/examples/
+
+      # Build the site exactly as boostorg/release-tools will at release
+      # time: invoke doc/build_antora.sh, which runs npm ci + npx antora
+      # against the committed package-lock.json.
+      - name: Build the site (release-tools entry point)
+        working-directory: doc
+        run: ./build_antora.sh playbook.yml

.github/workflows/warning-count-comment.yml

@@ -0,0 +1,61 @@
+name: warning-count-comment
+
+on:
+  workflow_run:
+    workflows: ["CI"]
+    types: [completed]
+
+permissions:
+  actions: read
+  pull-requests: write
+  contents: read
+
+jobs:
+  comment:
+    if: github.event.workflow_run.event == 'pull_request'
+    runs-on: ubuntu-latest
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      REPO: ${{ github.repository }}
+      PR_RUN: ${{ github.event.workflow_run.id }}
+      HEAD_SHA: ${{ github.event.workflow_run.head_sha }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download this PR run's log archive
+        run: gh api "repos/$REPO/actions/runs/$PR_RUN/logs" > pr-logs.zip
+
+      - name: Download latest successful develop run's log archive
+        run: |
+          DEV=$(gh run list --workflow CI --branch develop --status success \
+                  --limit 1 --json databaseId --jq '.[0].databaseId')
+          if [ -z "$DEV" ]; then echo "no develop baseline run found" >&2; exit 1; fi
+          echo "DEV_RUN=$DEV" >> "$GITHUB_ENV"
+          gh api "repos/$REPO/actions/runs/$DEV/logs" > base-logs.zip
+
+      - name: Generate table
+        run: |
+          {
+            echo "Compiler-warning counts vs \`develop\` (auto-generated)."
+            echo "PR run \`$PR_RUN\` vs develop run \`$DEV_RUN\` (\`${HEAD_SHA:0:10}\`)."
+            echo
+            python3 .github/scripts/warn_table.py base-logs.zip pr-logs.zip
+          } > table.md
+
+      - name: Resolve PR number
+        id: pr
+        run: |
+          num=$(gh api "repos/$REPO/pulls?state=open&per_page=100" \
+                  --jq "map(select(.head.sha==\"$HEAD_SHA\"))[0].number")
+          if [ -z "$num" ]; then
+            echo "no open PR found with head $HEAD_SHA" >&2
+            exit 1
+          fi
+          echo "num=$num" >> "$GITHUB_OUTPUT"
+
+      - name: Post or update sticky comment
+        uses: marocchino/sticky-pull-request-comment@v2
+        with:
+          header: warning-counts
+          number: ${{ steps.pr.outputs.num }}
+          path: table.md

.gitignore

@@ -0,0 +1,20 @@
+cube-fr.dot
+cube.dot
+disconnected-fr.dot
+graphml_test_out.xml
+kevin-bacon2.dat
+random.dot
+triangular-fr.dot
+triangular-kk.dot
+test/*.dot
+example/routing-table.dat
+example/figs/ospf-sptree.dot
+CMakeFiles/
+
+# Antora docs build artifacts
+doc/build/
+doc/node_modules/
+
+# macOS
+.DS_Store
+**/.DS_Store

CMakeLists.txt

@@ -0,0 +1,79 @@
+# Copyright 2020, 2021 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.8...3.16)
+
+project(boost_graph VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+
+add_library(boost_graph
+  src/graphml.cpp
+  src/read_graphviz_new.cpp
+)
+
+add_library(Boost::graph ALIAS boost_graph)
+
+target_include_directories(boost_graph PUBLIC include)
+
+target_link_libraries(boost_graph
+  PUBLIC
+    Boost::algorithm
+    Boost::any
+    Boost::array
+    Boost::assert
+    Boost::bimap
+    Boost::concept_check
+    Boost::config
+    Boost::container_hash
+    Boost::conversion
+    Boost::core
+    Boost::detail
+    Boost::foreach
+    Boost::function
+    Boost::integer
+    Boost::iterator
+    Boost::lexical_cast
+    Boost::math
+    Boost::move
+    Boost::mpl
+    Boost::multi_index
+    Boost::multiprecision
+    Boost::optional
+    Boost::parameter
+    Boost::preprocessor
+    Boost::property_map
+    Boost::property_tree
+    Boost::random
+    Boost::range
+    Boost::serialization
+    Boost::smart_ptr
+    Boost::spirit
+    Boost::throw_exception
+    Boost::tti
+    Boost::tuple
+    Boost::type_traits
+    Boost::typeof
+    Boost::unordered
+    Boost::utility
+    Boost::xpressive
+  PRIVATE
+    Boost::regex
+)
+
+target_compile_definitions(boost_graph
+  PUBLIC BOOST_GRAPH_NO_LIB
+  # Source files already define BOOST_GRAPH_SOURCE
+  # PRIVATE BOOST_GRAPH_SOURCE
+)
+
+if(BUILD_SHARED_LIBS)
+  target_compile_definitions(boost_graph PUBLIC BOOST_GRAPH_DYN_LINK)
+else()
+  target_compile_definitions(boost_graph PUBLIC BOOST_GRAPH_STATIC_LINK)
+endif()
+
+if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
+
+  add_subdirectory(test)
+
+endif()

CODE_OF_CONDUCT.md

@@ -0,0 +1,84 @@
+
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, caste, color, religion, or sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at `arnaud.becheler -at- gmail.com`. All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.1, available at [https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at [https://www.contributor-covenant.org/faq][FAQ]. Translations are available at [https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

CONTRIBUTING.md

@@ -0,0 +1,182 @@
+# Contributing to Boost.Graph
+
+## We are welcoming contributions
+
+- Bug fixes and test cases for them
+- New algorithms (with tests, documentation, complexity notes, and a reference)
+- Documentation, examples, performance work
+- Concept refinements (handle with care as these are API-visible)
+
+## Maintainers
+
+| Maintainer | Role | Focus | Availability | Contact |
+|---|---|---|---|---|
+| **Jeremy W. Murphy** | Principal maintainer. Holds merge authority and final say on design decisions. | Algorithms, technical review, library architecture. 10+ years on BGL. | Part-time, best-effort. | `jeremy.william.murphy -at- gmail.com` |
+| **Arnaud Becheler** | Assistant maintainer. Triage, review, and contributor support; defers to Jeremy on merge decisions. | Documentation, modernization, contributor onboarding. | Full-time, funded by the [C++ Alliance](https://cppalliance.org) to assist Jeremy. | `arnaud.becheler -at- gmail.com` |
+
+The authoritative maintainer list lives in [meta/libraries.json](meta/libraries.json); keep this section in sync with it. Maintainers aim to provide first-pass review on new PRs within two weeks.
+
+## Getting set up
+
+Clone the [Boost superproject](https://github.com/boostorg/boost):
+
+```bash
+git clone --depth 1 https://github.com/boostorg/boost
+cd boost
+git submodule update --init --depth 1
+./bootstrap.sh
+./b2 headers
+```
+
+Then replace `libs/graph/` with your fork:
+
+```bash
+rm -rf libs/graph
+git clone https://github.com/<you>/graph libs/graph
+cd libs/graph
+git remote add upstream https://github.com/boostorg/graph
+```
+
+## Building and testing
+
+- Headers only: `./b2 headers` from boost root
+- Compiled components: `./b2` from `libs/graph`
+- All tests: `./b2` from `libs/graph/test` (takes ~10 min)
+- Single test: `./b2 cycle_canceling_test` from `libs/graph/test`
+- Different C++ standard: `./b2 cxxstd=20`
+- Different compiler: `./b2 toolset=clang`
+
+### Naming conventions
+
+BGL follows the standard Boost / STL conventions:
+
+| Kind | Style | Example |
+|---|---|---|
+| Functions, types, variables, files | `snake_case` | `dijkstra_visitor`, `add_edge`, `adjacency_list.hpp` |
+| Member functions / methods | `snake_case` (same as free functions) | `get_edge`, `out_edges` |
+| Private member variables | `m_` prefix + `snake_case` | `m_matrix`, `m_num_edges`, `m_property` |
+| Concept names | `PascalCase` | `IncidenceGraph`, `VertexListGraph` |
+| Template parameters | `PascalCase` | `template <class Graph, class WeightMap>` |
+| Tag-dispatch types | `snake_case` + `S` suffix | `vecS`, `directedS` |
+| Macros | `BOOST_GRAPH_` prefix, `SCREAMING_SNAKE_CASE` | `BOOST_GRAPH_DECLARE_EDGE_PROPERTY` |
+
+### Formatting
+
+Low-level formatting (braces, column width, spaces in angle brackets, etc.) is captured by the [`.clang-format`](.clang-format) file at the repo root (WebKit preset with BGL-specific overrides: Allman braces, 80-column limit, `Cpp03`). It is **not** enforced by CI, but contributors are encouraged to run `clang-format -i` on files they touch before opening a PR.
+
+## Using other Boost libraries
+
+When writing new code:
+
+- **Prefer `std::`** when the supported C++ standard has an equivalent. Use `std::function`, `std::shared_ptr`, `std::tuple` over their Boost counterparts. Exceptions are welcome with justification in the PR description, in particular Boost containers with no std equivalent in our standard window (e.g. `boost::unordered_flat_map`, `boost::bimap`, `boost::multi_index_container`).
+- **Avoid pulling in new heavy dependencies** (Spirit, property_tree, xpressive, etc.) without justification: BGL is gradually migrating away from heavy Boost dependencies. Open a discussion before adding one.
+- **Concept checks** (`boost::concept`) are encouraged for any new public template. New public APIs should respect the existing concept hierarchy. 
+- Track BGL's position in the Boost dependency DAG via [boostdep](https://github.com/boostorg/boostdep)'s hosted reports. The long-term goal is to reduce BGL's level over time:
+    - **[Module levels](https://pdimov.github.io/boostdep-report/master/module-levels.html#graph)** shows BGL's depth in the global DAG. A rising level means new transitive Boost dependencies have been pulled in.
+    - **[Per-library page](https://pdimov.github.io/boostdep-report/develop/graph.html)** shows BGL's direct deps and per-dep `#include` counts.
+
+## Boost macro usage
+
+BGL has accumulated a wide vocabulary of `BOOST_*` macros from its pre-C++14 days. The table below captures the current guidance for each one used in the codebase: **Keep** as-is, **Replace** with a language or std equivalent, or **Remove** along with the dead `#if defined(...)` branch the macro guards. When in doubt, follow the recommendation here or ask before introducing new uses.
+
+| Macro | Recommendation |
+|---|---|
+| `BOOST_ASSERT` | Keep, more useful and configurable than `assert` |
+| `BOOST_BORLANDC` | Remove |
+| `BOOST_CONCEPT_ASSERT` | Keep (pre C++20) |
+| `BOOST_CONCEPT_REQUIRES` | Keep (pre C++20) |
+| `BOOST_CONCEPT_USAGE` | Keep (pre C++20) |
+| `BOOST_DEDUCED_TYPENAME` | Remove |
+| `BOOST_FOREACH` | Replace with an appropriate algorithm or range-based `for` loop |
+| `BOOST_FWD_REF` | Replace with `T&&` |
+| `BOOST_JOIN` | Keep |
+| `BOOST_MPL_HAS_XXX_TRAIT_DEF` | Consider writing the same utility without dependency on MPL |
+| `BOOST_MSVC` | Keep |
+| `BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP` | Remove |
+| `BOOST_NO_AUTO_PTR` | Remove and assume `auto_ptr` is not available |
+| `BOOST_NO_CXX11_ALLOCATOR` | Remove |
+| `BOOST_NO_CXX11_RVALUE_REFERENCES` | Remove |
+| `BOOST_NO_CXX11_SMART_PTR` | Remove |
+| `BOOST_NO_CXX17_STRUCTURED_BINDINGS` | Keep |
+| `BOOST_NO_MEMBER_TEMPLATE_FRIENDS` | Remove |
+| `BOOST_NO_SFINAE` | Remove |
+| `BOOST_NO_STDC_NAMESPACE` | Possibly keep |
+| `BOOST_NO_STD_ALLOCATOR` | Remove |
+| `BOOST_NO_STD_ITERATOR_TRAITS` | Remove |
+| `BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS` | Remove |
+| `BOOST_OVERRIDE` | Possibly remove |
+| `BOOST_PARAMETER_KEYWORD` | Keep |
+| `BOOST_PARAMETER_NAME` | Keep |
+| `BOOST_PP_CAT` | Use if Boost.PP can't be replaced with variadics |
+| `BOOST_PP_COMMA_IF` | Use if Boost.PP can't be replaced with variadics |
+| `BOOST_PP_DEC` | Use if Boost.PP can't be replaced with variadics |
+| `BOOST_PP_ENUM_BINARY_PARAMS` | Use if Boost.PP can't be replaced with variadics |
+| `BOOST_PP_ENUM_BINARY_PARAMS_Z` | Use if Boost.PP can't be replaced with variadics |
+| `BOOST_PP_ENUM_PARAMS` | Use if Boost.PP can't be replaced with variadics |
+| `BOOST_PP_ENUM_PARAMS_Z` | Use if Boost.PP can't be replaced with variadics |
+| `BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z` | Use if Boost.PP can't be replaced with variadics |
+| `BOOST_PP_ENUM_TRAILING_PARAMS_Z` | Use if Boost.PP can't be replaced with variadics |
+| `BOOST_PP_EXPR_IF` | Use if Boost.PP can't be replaced with variadics |
+| `BOOST_PP_INC` | Use if Boost.PP can't be replaced with variadics |
+| `BOOST_PP_LPAREN_IF` | Use if Boost.PP can't be replaced with variadics |
+| `BOOST_PP_REPEAT` | Use if Boost.PP can't be replaced with variadics |
+| `BOOST_PP_REPEAT_FROM_TO` | Use if Boost.PP can't be replaced with variadics |
+| `BOOST_PP_RPAREN_IF` | Use if Boost.PP can't be replaced with variadics |
+| `BOOST_PP_SEQ_ELEM` | Use if Boost.PP can't be replaced with variadics |
+| `BOOST_PP_SUB` | Use if Boost.PP can't be replaced with variadics |
+| `BOOST_PP_TUPLE_EAT` | Use if Boost.PP can't be replaced with variadics |
+| `BOOST_PREVENT_MACRO_SUBSTITUTION` | Keep |
+| `BOOST_SERIALIZATION_NVP` | Consider removing if you can eliminate the dependency on Boost.Serialization via `<boost/core/serialization.hpp>` |
+| `BOOST_SPIRIT_CLOSURE_LIMIT` | Keep |
+| `BOOST_SPIRIT_DEBUG` | Keep |
+| `BOOST_SPIRIT_DEBUG_RULE` | Keep |
+| `BOOST_STATIC_ASSERT` | Replace with `static_assert(..., msg)` |
+| `BOOST_STATIC_ASSERT_MSG` | Replace with `static_assert(..., msg)` |
+| `BOOST_STATIC_CONSTANT` | Remove in favour of in-class `static constexpr` initialization |
+| `BOOST_SYMBOL_EXPORT` | Keep |
+| `BOOST_SYMBOL_IMPORT` | Keep |
+| `BOOST_SYMBOL_VISIBLE` | Keep |
+| `BOOST_TESTED_AT` | Keep |
+| `BOOST_THROW_EXCEPTION` | Keep |
+| `BOOST_TTI_HAS_MEMBER_FUNCTION` | Consider writing the same utility without dependency on TTI |
+| `BOOST_USING_STD_MAX` | Replace with `(std::max)(...)` |
+| `BOOST_USING_STD_MIN` | Replace with `(std::min)(...)` |
+| `BOOST_WORKAROUND` | Keep |
+
+When you mark a `BOOST_NO_*` flag as **Remove**, also delete the `#if defined(...)` block it gates — the alternate branch is always taken on the supported toolchains.
+
+## Pull request process
+
+- Fork, branch from `develop`, PR back to `develop`
+- One logical change per PR; rebase before requesting review
+- Tests required for new features and bug fixes
+- **Open (non-draft) PRs are assumed ready for review.** Use GitHub's Draft state while iterating, then mark the PR as *Ready for review* when you want maintainers to look at it.
+- A maintainer will review within ~2 weeks (see Maintainers below)
+- Squash on merge by default
+
+## Merge criteria
+
+Before a PR is merged, all of the following must hold:
+
+1. CI is green on the full matrix (gcc-14 + clang-19, C++14/17/20/23).
+2. New behavior has tests.
+3. Bug fixes have a regression test.
+4. Documentation under [doc/](doc/) is updated if the public API changed.
+5. No new compiler warnings on the supported toolchains.
+6. The PR is rebased on current `develop` with a clean commit history.
+7. The principal maintainer has approved.
+
+## Reporting bugs
+
+1. Search [existing issues](https://github.com/boostorg/graph/issues) first
+2. Note compiler, version, OS, Boost version
+3. Minimal reproducer on [Compiler Explorer](https://godbolt.org/z/37dPWd5bs)
+4. Expected Output versus Actual Output is explained.
+
+## Security
+
+See [SECURITY.md](SECURITY.md).
+
+## License
+
+By contributing, you agree your contribution is licensed under the [Boost Software License 1.0](https://www.boost.org/LICENSE_1_0.txt).

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,106 @@
+# Boost Graph Library
+
+[![Docs](https://img.shields.io/badge/docs-boost.org-blue.svg)](https://www.boost.org/doc/libs/release/libs/graph/doc/index.html)
+[![C++14](https://img.shields.io/badge/C%2B%2B-14-blue.svg)](https://en.cppreference.com/w/cpp/14)
+[![CI](https://github.com/boostorg/graph/actions/workflows/ci.yml/badge.svg)](https://github.com/boostorg/graph/actions/workflows/ci.yml)
+[![License: BSL-1.0](https://img.shields.io/badge/License-BSL_1.0-blue.svg)](https://www.boost.org/LICENSE_1_0.txt)
+[![Boost release](https://img.shields.io/github/v/release/boostorg/boost?label=Boost&color=orange)](https://github.com/boostorg/boost/releases)
+
+The Boost Graph Library (BGL) is a generic library that allows users to:
+
+1. Represent graph data using different structures (adjacency matrix, adjacency list, compressed sparse row, vectors of vectors, user-defined data structures).
+2. Attach user-defined data to vertices, edges, or the graph itself.
+3. Run a large number of algorithms on the graph.
+4. Inject user logic into algorithms using visitor hooks.
+
+## Example
+
+[Try it on Compiler Explorer](https://godbolt.org/z/9Esszr9Ga)
+
+```cpp
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/dijkstra_shortest_paths.hpp>
+#include <boost/graph/visitors.hpp>
+#include <iostream>
+#include <limits>
+#include <vector>
+
+struct City {};
+struct Road { int cost; };
+
+using namespace boost;
+using Graph = adjacency_list<vecS, vecS, directedS, City, Road>;
+using Vertex = graph_traits<Graph>::vertex_descriptor;
+
+int main() {
+    Graph g(4);
+    add_edge(0, 1, Road{1}, g);
+    add_edge(1, 2, Road{2}, g);
+    add_edge(0, 2, Road{10}, g);
+    add_edge(2, 3, Road{1}, g);
+
+    // Storage: you control allocation, lifetime, and container type
+    std::vector<Vertex> storage_pred(num_vertices(g));
+    std::vector<int>    storage_dist(num_vertices(g));
+
+    // Property maps: lightweight views into the storage
+    auto index_map       = get(vertex_index, g);
+    auto costs_map       = get(&Road::cost, g);
+    auto predecessor_map = make_iterator_property_map(storage_pred.begin(), index_map);
+    auto distance_map    = make_iterator_property_map(storage_dist.begin(), index_map);
+
+    dijkstra_shortest_paths(g, vertex(0, g),
+        predecessor_map, distance_map,
+        costs_map, index_map,
+        std::less<int>(), std::plus<int>(),
+        std::numeric_limits<int>::max(), 0,
+        dijkstra_visitor<null_visitor>());
+
+    for (auto v : make_iterator_range(vertices(g)))
+        std::cout << "distance to " << v << " = " << storage_dist[v] << "\n";
+}
+```
+```
+distance to 0 = 0
+distance to 1 = 1
+distance to 2 = 3
+distance to 3 = 4
+```
+
+## Algorithms
+
+BGL ships dozens of graph algorithms: shortest paths (Dijkstra, Bellman-Ford, A*, Floyd-Warshall, Johnson), spanning trees (Kruskal, Prim), maximum flow (Edmonds-Karp, push-relabel, Boykov-Kolmogorov), traversal (BFS, DFS, topological sort), planarity testing, isomorphism, component decomposition, and more.
+
+See the [full algorithm reference](https://becheler.github.io/graph/graph/algorithms/overview.html) for the complete catalogue.
+
+## Help and feedback
+
+* **[GitHub Issues](https://github.com/boostorg/graph/issues)** for bug reports. Search before opening a new one.
+* **[GitHub Discussions](https://github.com/boostorg/graph/discussions)** for questions, design ideas, and general conversation about the library.
+* **[Boost mailing list](http://lists.boost.org/mailman/listinfo.cgi/boost-users)** for general Boost development. Use the `[graph]` tag in the subject line.
+* **CppLang Slack** for real-time chat. [Request an invite](https://cppalliance.org/slack/), then join the `#boost` channel.
+* **Direct contact with maintainers**: see [CONTRIBUTING.md#maintainers](CONTRIBUTING.md#maintainers).
+
+## Using BGL
+
+Install Boost via your package manager:
+
+| Manager | Command |
+|---|---|
+| [vcpkg](https://vcpkg.io) | `vcpkg install boost-graph` |
+| [Conan](https://conan.io) | `conan install --requires=boost/[*]` |
+| apt (Debian/Ubuntu) | `sudo apt install libboost-graph-dev` |
+| Homebrew (macOS) | `brew install boost` |
+
+Then wire it into CMake:
+
+```cmake
+find_package(Boost REQUIRED COMPONENTS graph)
+target_link_libraries(my_app PRIVATE Boost::graph)
+```
+
+Most of BGL is header-only. Linking `Boost::graph` is only required for the GraphViz and GraphML parsers.
+
+## Building from source
+
+For working on BGL itself (building Boost from source, running the test suite), see [CONTRIBUTING.md](CONTRIBUTING.md).

SECURITY.md

@@ -0,0 +1,14 @@
+# Security Policy
+
+Boost.Graph is a header-only C++ template library. Most issues that look
+like security problems are caused by misuse of the API, undefined behavior
+in caller code, or violating a documented precondition. Those should be
+filed as regular GitHub issues.
+
+If you believe you have found a genuine vulnerability in the library
+itself, please report it privately through GitHub's
+[private vulnerability reporting](https://github.com/boostorg/graph/security/advisories/new)
+rather than opening a public issue.
+
+Fixes land on the `develop` branch and ship with the next Boost release.
+No back-porting to older releases is guaranteed.

build.jam

@@ -0,0 +1,61 @@
+# Copyright René Ferdinand Rivera Morell 2024
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+require-b2 5.2 ;
+
+constant boost_dependencies :
+    /boost/algorithm//boost_algorithm
+    /boost/any//boost_any
+    /boost/array//boost_array
+    /boost/assert//boost_assert
+    /boost/bimap//boost_bimap
+    /boost/bind//boost_bind
+    /boost/concept_check//boost_concept_check
+    /boost/config//boost_config
+    /boost/container_hash//boost_container_hash
+    /boost/conversion//boost_conversion
+    /boost/core//boost_core
+    /boost/detail//boost_detail
+    /boost/foreach//boost_foreach
+    /boost/function//boost_function
+    /boost/integer//boost_integer
+    /boost/iterator//boost_iterator
+    /boost/lexical_cast//boost_lexical_cast
+    /boost/math//boost_math_tr1
+    /boost/move//boost_move
+    /boost/mpl//boost_mpl
+    /boost/multi_index//boost_multi_index
+    /boost/multiprecision//boost_multiprecision
+    /boost/optional//boost_optional
+    /boost/parameter//boost_parameter
+    /boost/preprocessor//boost_preprocessor
+    /boost/property_map//boost_property_map
+    /boost/property_tree//boost_property_tree
+    /boost/random//boost_random
+    /boost/range//boost_range
+    /boost/serialization//boost_serialization
+    /boost/smart_ptr//boost_smart_ptr
+    /boost/spirit//boost_spirit
+    /boost/throw_exception//boost_throw_exception
+    /boost/tti//boost_tti
+    /boost/tuple//boost_tuple
+    /boost/type_traits//boost_type_traits
+    /boost/typeof//boost_typeof
+    /boost/unordered//boost_unordered
+    /boost/utility//boost_utility
+    /boost/xpressive//boost_xpressive ;
+
+project /boost/graph
+    ;
+
+explicit
+    [ alias boost_graph : build//boost_graph ]
+    [ alias all : boost_graph example test ]
+    ;
+
+call-if : boost-library graph
+    : install boost_graph
+    ;
+

build/Jamfile

@@ -1,10 +0,0 @@
-subproject libs/graph/build ;
-
-SOURCES = graphviz_graph_lex graphviz_digraph_lex
-	 graphviz_graph_parser graphviz_digraph_parser ;
-
-
-lib libbgl-viz : ../src/$(SOURCES).cpp 
-	: <include>$(BOOST_ROOT)
-	: debug <inlining>on #inlining prevents linker name clashes due to truncation! 
-	;

build/Jamfile.v2

@@ -0,0 +1,32 @@
+# 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 ;
+
+constant boost_dependencies_private :
+    /boost/regex//boost_regex
+    ;
+
+project
+    : common-requirements <include>../include <library>$(boost_dependencies)
+    : requirements <include>../src <library>$(boost_dependencies_private)
+    : source-location ../src
+    : usage-requirements <define>BOOST_GRAPH_NO_LIB=1
+    ;
+
+lib boost_graph
+    :
+    read_graphviz_new.cpp
+    graphml.cpp
+    :
+    <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
+    :
+    :
+    ;

doc/AdjacencyGraph.html

@@ -1,166 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>AdjacencyGraph</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-
-
-<H2><A NAME="concept:AdjacencyGraph"></A>
-AdjacencyGraph
-</H2>
-
-The AdjacencyGraph concept provides and interface for efficient access
-of the adjacent vertices to a vertex in a graph. This is quite similar
-to the <a href="./IncidenceGraph.html">IncidenceGraph</a> concept (the
-target of an out-edge is an adjacent vertex). Both concepts are
-provided because in some contexts there is only concern for the
-vertices, whereas in other contexts the edges are also important.
-
-<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>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>
-
-<Table border>
-
-<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
-vertices adjacent to <i>v</i>.  As such, the value type of an
-adjacency iterator is the vertex descriptor type of its graph. An
-adjacency iterator must meet the requirements of <a
-href="../../utility/MultiPassInputIterator.html">MultiPassInputIterator</a>.
-</TD>
-</TR>
-
-</table>
-
-<h3>Valid Expressions</h3>
-
-
-<table border>
-
-<tr>
-<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="adjacencygraph.html#1">[1]</a>
-
-<br> Return type:
-<TT>std::pair&lt;adjacency_iterator,&nbsp;adjacency_iterator&gt;</TT>
-</TD>
-</TR>
-
-</table>
-
-<H3>Complexity guarantees</H3>
-
-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="./adjacency_iterator.html"><tt>adjacency_iterator</tt></a>
-
-<H3>Concept Checking Class</H3>
-
-<PRE>
-  template &lt;class G&gt;
-  struct AdjacencyGraphConcept
-  {
-    typedef typename boost::graph_traits&lt;G&gt;::adjacency_iterator
-      adjacency_iterator;
-    void constraints() {
-      function_requires&lt; IncidenceGraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; MultiPassInputIteratorConcept&lt;adjacency_iterator&gt; &gt;();
-
-      p = adjacent_vertices(v, g);
-      v = *p.first;
-      const_constraints(g);
-    }
-    void const_constraints(const G&amp; g) {
-      p = adjacent_vertices(v, g);
-    }
-    std::pair&lt;adjacency_iterator,adjacency_iterator&gt; p;
-    typename boost::graph_traits&lt;G&gt;::vertex_descriptor v;
-    G g;
-  };
-</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>
-
-<a name="1">[1]</a>  The case of a
-<I>multigraph</I> (where multiple edges can connect the same two
-vertices) brings up an issue as to whether the iterators returned by
-the <TT>adjacent_vertices()</TT> function access a range that
-includes each adjacent vertex once, or whether it should match the
-behavior of the <TT>out_edges()</TT> function, and access a
-range that may include an adjacent vertex more than once. For now the
-behavior is defined to match that of <TT>out_edges()</TT>,
-though this decision may need to be reviewed in light of more
-experience with graph algorithm implementations.
-
-
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../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/AdjacencyMatrix.html

@@ -1,90 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>AdjacencyMatrix</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-
-
-<H2><A NAME="concept:AdjacencyMatrix"></A>
-AdjacencyMatrix
-</H2>
-
-<P>
-The AdjacencyMatrix concept refines <a href="./Graph.html">Graph</a>
-concept and adds the requirement for efficient access to any edge in
-the graph given the source and target vertices. No Boost Graph Library
-algorithms currently use this concept. However there are algorithms
-not yet implemented such as Floyd-Warshall that would require this
-concept.
-
-<H3>Refinement of</H3>
-
-<a href="./Graph.html">Graph</a>
-
-<H3>Valid Expressions</H3>
-
-<table border>
-
-<tr>
-<th>Name</th><th>Expression</th><th>Return Type</th><th>Description</th>
-</tr>
-
-<tr>
-<td>Direct Edge Access</td>
-<TD><TT>edge(u,v,g)</TT></TD>
-<TD><TT>std::pair&lt;edge_descriptor, bool&gt;</TT></TD>
-<TD>
-Returns a pair consisting of a flag saying whether there exists an
-edge between <TT>u</TT> and <TT>v</TT> in graph <TT>g</TT>, and
-consisting of the edge descriptor if the edge was found.
-</TD>
-</TR>
-</TABLE>
-
-<H3>Models</H3>
-
-<a href="./adjacency_matrix.html"><tt>adjacency_matrix</tt></a>
-
-<H3>Concept Checking Class</H3>
-
-<PRE>
-  template &lt;class G&gt;
-  struct AdjacencyMatrix
-  {
-    typedef typename boost::graph_traits&lt;G&gt;::edge_descriptor edge_descriptor;
-    void constraints() {
-      p = edge(u, v, g);
-    }
-    typename boost::graph_traits&lt;G&gt;::vertex_descriptor u, v;
-    std::pair&lt;bool, edge_descriptor&gt; p;
-    G g;
-  };
-</PRE>
-
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../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/BFSVisitor.html

@@ -1,203 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: BFSVisitor</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1>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 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>
-
-<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 BFS 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>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 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>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>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
-edges for undirected graphs.
-</td>
-</tr>
-
-<tr>
-<td>Gray Target</td>
-<td><tt>vis.gray_target(e, g)</tt></td>
-<td><tt>void</tt></td>
-<td>
-This is invoked on the subset of non-tree edges who's target vertex is
-colored gray at the time of examination. The color gray indicates
-that the vertex is currently in the queue. 
-</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 on the subset of non-tree edges who's target vertex is
-colored black at the time of examination. The color black indicates
-that the vertex has been removed from the queue.
-</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 the out-edges of the adjacent vertices have been examined).
-</td>
-</tr>
-
-</table>
-
-<h3>Models</h3>
-
-<ul>
- <li><a href="./bfs_visitor.html"><tt>bfs_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 2000-2001</TD><TD>
-<A HREF="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/BasicMatrix.html

@@ -1,107 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>BasicMatrix</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     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="../../../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,175 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: Bellman Ford Visitor</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1>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 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>
-
-<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 Bellman Ford 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>Examine Edge</td>
-<td><tt>vis.examine_edge(e, g)</tt></td>
-<td><tt>void</tt></td>
-<td>
-This is invoked on every edge in the graph <tt>num_vertices(g)</tt> times.
-</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>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>Edge Minimized</td>
-<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
-each edge was minimized. If the edge is minimized then this function
-is invoked.
-</td>
-</tr>
-
-<tr>
-<td>Edge Not Minimized</td>
-<td><tt>edge_not_minimized(e, g)</tt></td>
-<td><tt>void</tt></td>
-<td>
-If the edge is not minimized, this function is invoked. This happens
-when there is a negative cycle in the graph.
-</td>
-</tr>
-
-</table>
-
-
-<h3>Models</h3>
-
-<ul>
-  <li><a href="./bellman_visitor.html"><tt>bellman_visitor</tt></a>
-</ul>
-
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/BidirectionalGraph.html

@@ -1,173 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Bidirectional</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-
-<H2>
-<A NAME="concept:BidirectionalGraph"></A>
-BidirectionalGraph
-</H2>
-
-<P>
-The BidirectionalGraph concept refines <a
-href="./IncidenceGraph.html">IncidenceGraph</a> and adds the
-requirement for efficient access to the in-edges of each vertex. This
-concept is separated from <a
-href="./IncidenceGraph.html">IncidenceGraph</a> because for directed
-graphs efficient access to in-edges typically requires more storage
-space, and many algorithms do not require access to in-edges.  For
-undirected graphs this is not an issue, since the <TT>in_edges()</TT>
-and <TT>out_edges()</TT> functions are the same, they both return the
-edges incident to the vertex.
-
-<H3>Refinement of</H3>
-
-<a href="./IncidenceGraph.html">IncidenceGraph</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>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>
-
-<Table border>
-
-<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
-in-edges of <i>v</i>.  As such, the value type of an in-edge iterator
-is the edge descriptor type of its graph. An in-edge iterator must
-meet the requirements of <a href="../../utility/MultiPassInputIterator.html">MultiPassInputIterator</a>.
-</TD>
-</TR>
-
-</Table>
-
-<h3>Valid Expressions</h3>
-
-<Table border>
-
-<tr>
-<td><a name="sec:in-edges"><TT>in_edges(v, g)</TT></a></TD>
-<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>.
-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>
-
-<tr>
-<TD><TT>in_degree(v, g)</TT></TD>
-<TD>
-Returns the number of in-edges (for directed graphs) or the
-number of incident edges (for undirected graphs) of vertex <TT>v</TT>
-in graph <TT>g</TT>.<br>
-Return type: <TT>degree_size_type</TT>
-</TD>
-</TR>
-
-<tr>
-<TD><TT>degree(v, g)</TT></TD>
-<TD>Returns the number of in-edges plus out-edges (for directed graphs) or the
-number of incident edges (for undirected graphs) of vertex <TT>v</TT>
-in graph <TT>g</TT>.<br>
-Return type: <TT>degree_size_type</TT>
-</TD>
-</TR>
-
-</Table>
-
-<H3>Models</H3>
-
-<ul>
-<li><a href="./adjacency_list.html"><tt>adjacency_list</tt></a> with <tt>Directed=bidirectionalS</tt></li>
-<li><a href="./adjacency_list.html"><tt>adjacency_list</tt></a> with <tt>Directed=undirectedS</tt></li>
-</ul>
-
-
-<H3>Complexity guarantees</H3>
-
-The <TT>in_edges()</TT> function is required to be constant time.  The
-<tt>in_degree()</tt> and <tt>degree()</tt> functions must be linear in
-the number of in-edges (for directed graphs) or incident edges (for
-undirected graphs).
-
-<H3>See Also</H3>
-
-<a href="./graph_concepts.html">Graph concepts</a>
-
-<H3>Concept Checking Class</H3>
-
-<PRE>
-  template &lt;class G&gt;
-  struct BidirectionalGraph_concept
-  {
-    typedef typename boost::graph_traits&lt;G&gt;::in_edge_iterator
-      in_edge_iterator;
-    void constraints() {
-      function_requires&lt; IncidenceGraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; MultiPassInputIteratorConcept&lt;in_edge_iterator&gt; &gt;();
-
-      p = in_edges(v, g);
-      e = *p.first;
-      const_constraints(g);
-    }
-    void const_constraints(const G&amp; g) {
-      p = in_edges(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;
-    G g;
-  };
-</PRE>
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../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/Buffer.html

@@ -1,123 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Buffer</Title>
-</HEAD>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<h3>Buffer Concept</h3>
-
-A Buffer is something in which items can be put and removed.
-The Buffer <i>concept</i> has very few requirements. It does
-not require any particular ordering of how the items are stored or in
-what order they will appear when removed, however, there is typically
-some sort of ordering policy.
-
-<h3>Notation</h3>
-
-<table>
-<tr> <td> <tt>B</tt> </td>  <td> is a type that models Buffer.       </td></tr>
-<tr> <td> <tt>T</tt> </td>  <td> is the value type of <tt>B</tt>. </td></tr>
-<tr> <td> <tt>t</tt> </td>  <td> is an object of type <tt>T</tt>. </td></tr>
-</table>
-
-
-<h3>Members</h3>
-
-For a type to model the Buffer concept it must have the following members.
-
-<p>
-
-<table border="1">
-
-<tr> <td><b>Member</b></td> <td><b>Description</b></td> </tr>
-
-<tr> <td> <tt>value_type</tt> </td> 
-     <td> The type of object stored in the Buffer. The value type
-          must be <A href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>.</td>
-    </tr>
-
-<tr> <td> <tt>size_type</tt>  </td>
-     <td> An unsigned integral type for representing the number of
-          objects in the Buffer.</td>
-    </tr>
-
-<tr> <td> <tt>void push(const T& t)</tt> </td>
-     <td> Inserts <tt>t</tt> into the Buffer. <tt>size()</tt> will be
-          incremented by one.</td>
-     </tr>
-
-<tr> <td> <tt>void pop()</tt> </td>
-     <td> Removes an object from the Buffer. <tt>size()</tt> will be
-          decremented by one. Precondition: <tt>empty()</tt>
-          is <tt>false</tt>. </td>
-     </tr>
-
-<tr> <td> <tt>T& top()</tt> </td>
-     <td> Returns a mutable reference to some object in the Buffer.
-          Precondition: <tt>empty()</tt> is <tt>false</tt>.</td>
-     </tr>
-
-<tr> <td> <tt>const T& top() const</tt> </td>
-     <td> Returns a const reference to some object in the Buffer. 
-          Precondition: <tt>empty()</tt> is <tt>false</tt>.</td>
-     </tr>
-
-<tr> <td> <tt>void size() const</tt> </td>
-     <td> Returns the number of objects in the Buffer.
-          Invariant: <tt>size() >= 0</tt>. </td>
-     </tr>
-
-<tr> <td> <tt>bool empty() const</tt> </td>
-     <td> Equivalent to <tt>b.size() == 0</tt>.</td>
-     </tr>
-
-</table>
-
-<h3>Complexity Guarantees</h3>
-
-<UL>
-
-<LI> <tt>push()</tt>, <tt>pop()</tt>, and <tt>size()</tt> must be at
-most linear time complexity in the size of the Generalized Queue.
-
-<LI> <tt>top()</tt> and <tt>empty()</tt> must be amortized constant time.
-
-</UL>
-
-<h3>Models</h3>
-
-<UL>
-<LI><a href="http://www.sgi.com/tech/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>
-</UL>
-
-<p>
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../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>
-</HTML> 
-

doc/CONTRIBUTING.md

@@ -0,0 +1,85 @@
+# Contributing to the Boost.Graph documentation
+
+The docs are built with [Antora](https://antora.org) from AsciiDoc
+sources under `doc/modules/ROOT/`.
+
+## Layout
+
+| Where | What |
+|---|---|
+| `doc/modules/ROOT/pages/`     | All `.adoc` pages (organized by topic) |
+| `doc/modules/ROOT/examples/`  | One `.cpp` per page; the build script captures stdout into a sibling `.txt` |
+| `doc/modules/ROOT/nav.adoc`   | Left-side navigation tree |
+| `doc/templates/`              | Starter templates: `algorithm.adoc`, `generator.adoc`, `graph_class.adoc` — copy and fill in |
+| `doc/playbook.yml`            | Antora playbook (UI bundle, content sources) |
+| `doc/modules/ROOT/examples/Jamfile` | b2 rules that compile every example and snapshot its stdout into a sibling `.txt` |
+| `doc/build_example_outputs.sh`| g++-only fallback that does the same thing as the Jamfile, for contributors without a `boost-root` checkout |
+
+## Adding a new page
+
+1. Pick a template in `doc/templates/` and copy it into the right
+   `pages/` subdirectory.
+2. Replace the placeholders (title, signatures, parameter table). Keep
+   the section order from the template so the page is consistent with
+   the rest.
+3. Add an `.cpp` example under `modules/ROOT/examples/` at the path
+   the page's `include::example$…[]` directive points to.
+4. Add an `xref:` line to `doc/modules/ROOT/nav.adoc`.
+
+## Building locally
+
+The example outputs are generated by b2 (the standard Boost build
+system). From a `boost-root` layout:
+
+```sh
+# 1) Compile every example and snapshot its stdout into a sibling .txt.
+b2 libs/graph/doc/modules/ROOT/examples
+
+# 2) Build the static site.
+cd libs/graph
+npx antora doc/playbook.yml
+
+# 3) Open the result.
+open doc/build/site/index.html       # macOS
+xdg-open doc/build/site/index.html   # Linux
+```
+
+CI runs the same commands on every push.
+
+### Quick fallback (no boost-root required)
+
+For doc-only contributors who only want to fix typos and don't have a
+boost-root checkout, a shell-script equivalent is provided:
+
+```sh
+BOOST_INCLUDE=/path/to/boost/include \
+BOOST_LIB=/path/to/boost/lib \
+bash doc/build_example_outputs.sh
+```
+
+Functionally equivalent to step 1 above; uses g++ directly instead of
+b2. `BOOST_LIB` is only needed for the three link-required examples
+(`io/graphml.cpp`, `io/graphviz.cpp`,
+`algorithms/isomorphism/isomorphism.cpp`).
+
+## Conventions
+
+- **Examples first.** `== Example` (with `*Expected output:*` block)
+  goes immediately after `*Defined in:*` so readers see working code
+  before signatures.
+- **Bold metadata.** `*Complexity:*`, `*Defined in:*`,
+  `*Expected output:*` are bold.
+- **Output blocks** use `[,text]\n----` (same listing-block wrapper as
+  the code above) and pull from the `.txt` sidecar via
+  `include::example$…[]`, so the documentation can never drift from the
+  code and the two blocks align vertically on the page.
+- **Heading levels:** `==` for top-level sections; `===` only for
+  numbered overloads or grouped variants. The `'''` thematic break
+  appears only before a `===`, never before a `==`.
+- **Bundled properties** preferred over interior tag properties in
+  examples, unless the algorithm requires the tag.
+
+## License
+
+By contributing you agree to license your contribution under the
+[Boost Software License 1.0](http://www.boost.org/LICENSE_1_0.txt).

doc/ColorValue.html

@@ -1,112 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: ColorValue Concept</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-
-<H1><A NAME="concept:ColorValue"></A>
-ColorValue
-</H1>
-
-<P>
-This concept describes the requirements for the type used for color
-values, as in for coloring a graph during a breath-first search to
-mark which vertices have been visited.
-
-<P>
-
-<h3>Refinement of</h3> <a
-href="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</a>
-and <a
-href="http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a>
-
-
-<h3>Notation</h3>
-
-<Table>
-<TR>
-<TD><tt>T</tt></TD>
-<TD>A type that is a model of ColorValue.</TD>
-</TR>
-
-<TR>
-<TD><tt>cv</tt></TD>
-<TD>An object of type <tt>T</tt>.</TD>
-</TR>
-
-</table>
-
-<h3>Valid Expressions</h3>
-
-<Table border>
-
-<tr>
-<th>Name</th><th>Expression</th><th>Return Type</th><th>Description</th>
-</tr>
-
-<tr>
-<td>Get Color White </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>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>color_traits&lt;T&gt;::black()</TT></TD>
-<TD><TT>T</TT></TD>
-<TD>Returns an object that represents the color black.</TD>
-</TR>
-
-</TABLE>
-
-<P>
-</LI>
-</UL>
-
-<h3>Models</h3>
-
-<ul>
-  <li><tt>default_color_type</tt> (in <a href="../../../boost/graph/properties.hpp"><tt>boost/graph/properties.hpp</tt>)
-</ul>
-
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/DFSVisitor.html

@@ -1,193 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>DFS Visitor</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1>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 and
-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 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 call 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>
-
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/DijkstraVisitor.html

@@ -1,202 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: Dijkstra Visitor</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1>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/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/ReadWritePropertyMap.html">Readable Property Map</a>.</TD>
-</TR>
-
-<TR>
-<TD><tt>w</tt></TD>
-<TD>An object of type <tt>DistanceMap</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="./ucs_visitor.html"><tt>ucs_visitor</tt></a>
-</ul>
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/EdgeListGraph.html

@@ -1,182 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>EdgeListGraph</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-
-<H2><A NAME="concept:EdgeListGraph"></A>
-EdgeListGraph
-</H2>
-
-The EdgeListGraph concept refines the <a href="./Graph.html">Graph</a>
-concept, and adds the requirement for efficient access to all the
-edges in the graph.
-
-
-<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 EdgeListGraph.</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>
-
-</table>
-
-<H3>Associated Types</H3>
-
-<table border>
-
-<tr>
-<td><pre>boost::graph_traits&lt;G&gt;::edge_iterator</pre>
-An edge iterator (obtained via <TT>edges(g)</TT>) provides access to
-all of the edges in a graph. An edge iterator type must meet the
-requirements of <a
-href="../../utility/MultiPassInputIterator.html">MultiPassInputIterator</a>.  The
-value type of the edge iterator must be the same as the edge
-descriptor of the graph.
-
-<tr>
-<td><pre>boost::graph_traits&lt;G&gt;::edges_size_type</pre>
-The unsigned integer type used to represent the number of edges in the
-graph.
-</td>
-</tr>
-
-</table>
-
-<h3>Valid Expressions</h3>
-
-<table border>
-
-<tr>
-<TD><a name="sec:edges"><TT>edges(g)</TT></a></TD>
-<TD>Returns an iterator-range providing access to all
-     the edges in the graph <TT>g</TT>.<br>
-Return type: <TT>std::pair&lt;edge_iterator, edge_iterator&gt;</TT>
-</td>
-</TR>
-
-<tr>
-<TD><TT>num_edges(g)</TT></TD>
-<TD>Returns the number of edges in the graph <TT>g</TT>.<br>
-Return type: <TT>edges_size_type</TT>
-</td>
-</TR>
-
-<tr>
-<TD><TT>source(e, g)</TT></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>
-</tr>
-
-<tr>
-<TD><TT>target(e, g)</TT></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>
-
-</TABLE>
-
-
-<H3>Models</H3>
-
-<UL>
-<LI><a href="./adjacency_list.html"><TT>adjacency_list</TT></a></LI>
-<LI><a href="./edge_list.html"><TT>edge_list</TT></a></LI>
-</UL>
-
-
-<H3>Complexity guarantees</H3>
-
-The <TT>edges()</TT>, <TT>source()</TT>, and <TT>target()</TT> functions
-must all return in constant time.
-
-
-<H3>See Also</H3>
-
-<a href="./graph_concepts.html">Graph concepts</a>
-
-<H3>Concept Checking Class</H3>
-
-<P>
-<PRE>
-  template &lt;class G&gt;
-  struct EdgeListGraphConcept
-  {
-    typedef typename boost::graph_traits&lt;G&gt;::edge_iterator 
-      edge_iterator;
-    void constraints() {
-      function_requires&lt; GraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; MultiPassInputIteratorConcept&lt;edge_iterator&gt; &gt;();
-
-      p = edges(g);
-      E = num_edges(g);
-      e = *p.first;
-      u = source(e, g);
-      v = target(e, g);
-      const_constraints(g);
-    }
-    void const_constraints(const G&amp; g) {
-      p = edges(g);
-      E = num_edges(g);
-      e = *p.first;
-      u = source(e, g);
-      v = target(e, g);
-    }
-    std::pair&lt;edge_iterator,edge_iterator&gt; p;
-    typename boost::graph_traits&lt;G&gt;::vertex_descriptor u, v;
-    typename boost::graph_traits&lt;G&gt;::edge_descriptor e;
-    typename boost::graph_traits&lt;G&gt;::edges_size_type E;
-    G g;
-  };
-</PRE>
-
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../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/EdgeMutableGraph.html

@@ -1,112 +0,0 @@
-<HTML>
-<!--
-  -- 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.
-  -->
-<Head>
-<Title>Edge Mutable Graph</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     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="../../../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,165 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: EventVisitor</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1>EventVisitor Concept</H1>
-
-This concept defines the interface for single-event visitors. An
-EventVisitor has an apply member function (<tt>operator()</tt>) which
-is invoked within the graph algorithm at the event-point specified by
-the <tt>event_filter</tt> typedef within the
-EventVisitor. EventVisitor's can be combined into an <a
-href="./EventVisitorList.html">EventVistorList</a>.
-
-<p>
-The following is the list of event tags that can be invoked in BGL
-algorithms. Each tag corresponds to a member function of the visitor
-for an algorithm. For example, the <a
-href="./BFSVisitor.html">BFSVisitor</a> of <a
-href="./breadth_first_search.html"><tt>breadth_first_search()</tt></a>
-has a <tt>cycle_edge()</tt> member function. The corresponding tag is
-<tt>on_cycle_edge</tt>. The first argument is the event visitor's
-<tt>operator()</tt> must be either an edge or vertex descriptor
-depending on the event tag.
-
-<pre>
-namespace boost {
-  struct on_initialize_vertex { };
-  struct on_start_vertex { };
-  struct on_discover_vertex { };
-  struct on_examine_edge { };
-  struct on_tree_edge { };
-  struct on_cycle_edge { };
-  struct on_finish_vertex { };
-  struct on_forward_or_cross_edge { };
-  struct on_back_edge { };
-  struct on_edge_relaxed { };
-  struct on_edge_not_relaxed { };
-  struct on_edge_minimized { };
-  struct on_edge_not_minimized { };
-} // namespace boost
-</pre>
-
-
-<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>G</tt></TD>
-<TD>A type that is a model of <a href="./Graph.html">Graph</a>.</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>A type that is a model of EventVisitor.</TD>
-</TR>
-
-<TR>
-<TD><tt>vis</tt></TD>
-<TD>An object of type <tt>V</tt>.</TD>
-</TR>
-
-<TR>
-<TD><tt>x</tt></TD>
-<TD>An object of type
-<tt>boost::graph_traits&lt;G&gt;::vertex_descriptor</tt>
-or <tt>boost::graph_traits&lt;G&gt;::edge_descriptor</tt>.</TD>
-</TR>
-
-</table>
-
-<h3>Associated Types</h3>
-
-<Table border>
-
-<TR>
-<TD>Event Filter </TD>
-<TD><TT>V::event_filter</TT></TD>
-<TD>
-A tag struct to specify on which event the visitor should be invoked.
-</TD>
-</TR>
-
-</table>
-
-<h3>Valid Expressions</h3>
-
-<Table border>
-
-<tr>
-<th>Name</th><th>Expression</th><th>Return Type</th><th>Description</th>
-</tr>
-
-<tr>
-<td>Apply Visitor</td>
-<td><TT>vis(x, g)</TT></TD>
-<TD><TT>void</TT></TD>
-<TD>
-Invokes the visitor operation on object <tt>x</tt>, which is
-either a vertex or edge descriptor of the graph.
-</TD>
-</TR>
-
-
-</table>
-
-
-<h3>Models</h3>
-
-<ul>
- <li><a
- href="./predecessor_recorder.html"><tt>predecessor_recorder</tt></a>
- <li><a href="./distance_recorder.html"><tt>distance_recorder</tt></a>
- <li><a href="./time_stamper.html"><tt>time_stamper</tt></a>
- <li><a href="./property_writer.html"><tt>property_writer</tt></a>
- <li><a href="./null_visitor.html"><tt>null_visitor</tt></a>
-</ul>
-
-<h3>See Also</h3>
-
-<a href="./EventVisitorList.html">EventVisitorList</a>,
-<a href="./visitor_concepts.html">Visitor concepts</a>
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/EventVisitorList.html

@@ -1,131 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: EventVisitorList</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1>EventVisitorList Concept</H1>
-
-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
-defines visitor adaptors that convert an EventVisitorList into the
-particular kind of visitor needed by the algorithm.
-
-In the following example we will show how to combine event visitors
-into a list using <tt>std::pair</tt> and how to use an algorithm's
-visitor adaptor class.
-
-<p>
-Suppose we would like to print out the parenthesis
-structure of the discover/finish times of vertices in a <a
-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="../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
-of event points specified in <a
-href="./DFSVisitor.html">DFSVisitor</a>.
-
-<pre>
-struct open_paren : public base_visitor&lt;open_paren&gt; {
-  typedef on_discover_vertex event_filter;
-  template &lt;class Vertex, class Graph&gt;
-  void operator()(Vertex v, Graph& G) {
-    std::cout &lt;&lt; "(" &lt;&lt; v;
-  }
-};
-struct close_paren : public base_visitor&lt;close_paren&gt; {
-  typedef on_finish_vertex event_filter;
-  template &lt;class Vertex, class Graph&gt;
-  void operator()(Vertex v, Graph& G) {
-    std::cout &lt;&lt; v &lt;&lt; ")";
-  }
-};
-</pre>
-
-Next we create two event visitor objects and make an EventVisitorList
-out of them using a <tt>std::pair</tt> which created by
-<tt>std::make_pair</tt>.
-
-<pre>
-std::make_pair(open_paren(), close_paren())
-</pre>
-
-Next we want to pass this list into <tt>depth_first_search()</tt>, but
-<tt>depth_first_search()</tt> is expecting a <a
-href="./DFSVisitor.html">DFSVisitor</a>, not a EventVisitorList.  We
-therefore use the <a
-href="./dfs_visitor.html"><tt>dfs_visitor</tt></a> adaptor which turns
-an EventVisitor list into a DFSVisitor. Like all of the visitor
-adaptors, <tt>dfs_visitor</tt> has a creation function called
-<tt>make_dfs_visitor()</tt>.
-
-<pre>
-make_dfs_visitor(std::make_pair(open_paren(), close_paren()))
-</pre>
-
-Now we can pass the resulting visitor object into
-<tt>depth_first_search()</tt> as follows.
-
-<pre>
-  // graph object G is created ...
-
-  std::vector&lt;default_color_type&gt; color(num_vertices(G));
-
-  depth_first_search(G, make_dfs_visitor(std::make_pair(open_paren(), close_paren())),
-                     color.begin());
-</pre>
-
-For creating a list of more than two event visitors, nest calls to
-<tt>std::make_pair</tt> in the following way:
-
-<pre>
-std::make_pair(<i>visitor1</i>,
-  std::make_pair(<i>visitor2</i>,
-    ...
-    std::make_pair(<i>visitorN-1</i>, <i>visitorN</i>)...));
-</pre>
-
-
-
-<h3>See Also</h3>
-
-<a href="./EventVisitor.html">EventVisitor</a>,
-<a href="./visitor_concepts.html">Visitor concepts</a>
-
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/Graph.html

@@ -1,143 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Graph</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     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., and the
-<tt>num_vertices()</tt> and <tt>num_edges()</tt> functions. One should
-note that a model of Graph is <B>not</B> required to be a model of <a
-href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>,
-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.sgi.com/tech/stl/DefaultConstructible.html">Default Constructible</a>,
-<a href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>, and
-<a href="http://www.sgi.com/tech/stl/EqualityComparable.html">Equality Comparable</a>.
-</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.sgi.com/tech/stl/DefaultConstructible.html">Default Constructible</I>,
-<a
-href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>,
-and <a href="http://www.sgi.com/tech/stl/EqualityComparable.html">Equality Comparable</a>.
-</td>
-</tr>
-
-<tr>
-<td><pre>boost::graph_traits&lt;G&gt;::directed_category</pre>
-The choices are <TT>directed_tag</TT> and <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>
-
-None required.
-
-<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() {
-      function_requires&lt; DefaultConstructibleConcept&lt;vertex_descriptor&gt; &gt;();
-      function_requires&lt; EqualityComparableConcept&lt;vertex_descriptor&gt; &gt;();
-      function_requires&lt; AssignableConcept&lt;vertex_descriptor&gt; &gt;();
-      function_requires&lt; DefaultConstructibleConcept&lt;edge_descriptor&gt; &gt;();
-      function_requires&lt; EqualityComparableConcept&lt;edge_descriptor&gt; &gt;();
-      function_requires&lt; AssignableConcept&lt;edge_descriptor&gt; &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="../../../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,199 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>IncidenceGraph</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1><A NAME="concept:IncidenceGraph"></A>
-IncidenceGraph
-</H1>
-
-The IncidenceGraph concept provides an interface for
-efficient access to the out-edges of each vertex in the graph.
-
-
-<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 IncidenceGraph.</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>
-
-</table>
-
-<H3>Associated Types</H3>
-
-<Table border>
-
-<TR>
-<TD>
-<pre>boost::graph_traits&lt;G&gt;::out_edge_iterator</pre>
-An out-edge iterator for a vertex <i>v</i> provides access to the
-out-edges of the vertex.  As such, the value type of an out-edge
-iterator is the edge descriptor type of its graph. An out-edge
-iterator must meet the requirements of <a
-href="../../utility/MultiPassInputIterator.html">MultiPassInputIterator</a>.
-</TD>
-</TR>
-
-<TR>
-<TD><pre>boost::graph_traits&lt;G&gt;::degree_size_type</pre>
-The unsigned intergral type used for representing the number
-out-edges or incident edges of a vertex.
-</TD>
-</TR>
-
-</table>
-
-<h3>Valid Expressions</h3>
-
-<Table border>
-
-<tr>
-<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>
-</TR>
-
-
-<tr>
-<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(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 and 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 the a vertex
-adjacent to <tt>u</tt>.<a href="">[1]</a>
-<br>
-Return type: <TT>std::pair&lt;out_edge_iterator, out_edge_iterator&gt;</TT>
-</TD>
-</tr>
-
-<tr>
-<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>u</TT>
-in graph <TT>g</TT>.<br>
-Return type: <TT>degree_size_type</TT>
-</TD>
-</TR>
-
-</TABLE>
-
-<P>
-
-<H3>Complexity guarantees</H3>
-
-<P>
-The <TT>source()</TT>, <TT>target()</TT>, and <TT>out_edges()</TT>
-functions must all be constant time. The <tt>out_degree()</tt>
-function must be linear in the number of out-edges.
-
-<P>
-
-<H3>See Also</H3>
-
-<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 IncidenceGraphConcept
-  {
-    typedef typename boost::graph_traits&lt;G&gt;::out_edge_iterator out_edge_iterator;
-    void constraints() {
-      function_requires&lt; GraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; MultiPassInputIteratorConcept&lt;out_edge_iterator&gt; &gt;();
-
-      p = out_edges(v, g);
-      e = *p.first;
-      u = source(e, g);
-      v = target(e, g);
-    }
-    void const_constraints(const G&amp; g) {
-      p = out_edges(v, g);
-      e = *p.first;
-      u = source(e, g);
-      v = target(e, g);
-    }
-    std::pair&lt;out_edge_iterator, out_edge_iterator&gt; p;
-    typename boost::graph_traits&lt;G&gt;::vertex_descriptor u, v;
-    typename boost::graph_traits&lt;G&gt;::edge_descriptor e;
-    G g;
-  };
-</PRE>
-
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/IteratorConstructibleGraph.html

@@ -1,165 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>IteratorConstructibleGraph</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     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.sgi.com/tech/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.sgi.com/tech/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="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/Makefile

@@ -1,95 +0,0 @@
-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

@@ -1,126 +0,0 @@
-<HTML>
-<!--
-  -- Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 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.  We make no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
-  -->
-<Head>
-<Title>Monoid</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     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.sgi.com/tech/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="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/MutableGraph.html

@@ -1,303 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>MutableGraph</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     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.sgi.com/tech/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() {
-      function_requires&lt; MutableGraph&lt;G&gt; &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() {
-      function_requires&lt; MutableIncidenceGraph&lt;G&gt; &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() {
-      function_requires&lt; MutableGraph&lt;G&gt; &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="../../../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,154 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>MutablePropertyGraph</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-
-
-<H2>
-<A NAME="sec:MutablePropertyGraph"></A>
-MutablePropertyGraph
-</H2>
-
-A MutablePropertyGraph is a <a
-href="./MutableGraph.html">MutableGraph</a> with properties attached
-internally to the vertices and edges. When adding vertices and edges
-the value of the properties can be given.
-
-
-<H3>Refinement of</H3>
-
-<a href="./MutableGraph.html">MutableGraph</a> and
-<a href="./PropertyGraph.html">PropertyGraph</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>ep</TT></TD><TD>is an object of type <TT>G::edge_property_type</TT></TD>
-</TR>
-
-<TR>
-<TD><TT>vp</TT></TD><TD>is an object of type <TT>G::vertex_property_type</TT></TD>
-</TR>
-
-</TABLE>
-
-<P>
-
-<H3>Associated Types</H3>
-
-<table border>
-
-<tr>
-<td>Edge Property Type </td>
-<td><TT>graph_traits&lt;G&gt;::edge_property_type</TT></td>
-</tr>
-
-<tr>
-<td>Vertex Property Type </td>
-<td><TT>graph_traits&lt;G&gt;::vertex_property_type</TT> </td>
-</tr>
-
-</table>
-
-<H3>Valid Expressions</h3>
-
-<table border>
-
-<tr>
-<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>
-Return type: <TT>std::pair&lt;edge_descriptor, bool&gt;</TT></TD>
-</TR>
-
-<tr>
-<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
-property for the new vertex. The <TT>vertex_descriptor</TT> for the new
-vertex is returned.<br>
-Return type: <TT>vertex_descriptor</TT>
-</TD>
-</TR>
-
-</TABLE>
-
-
-<H3>Models</H3>
-
-<UL>
-<LI><TT>adjacency_list</TT></LI>
-</UL>
-
-<H3>Concept Checking Class</H3>
-
-<P>
-<PRE>
-  template &lt;class G&gt;
-  struct MutablePropertyGraphConcept
-  {
-    typedef typename boost::graph_traits&lt;G&gt;::edge_descriptor edge_descriptor;
-    void constraints() {
-      function_requires&lt; MutableGraphConcept&lt;G&gt; &gt;();
-      v = add_vertex(vp, g);
-      p = add_edge(u, v, ep, g);
-    }
-    G g;
-    std::pair&lt;edge_descriptor, bool&gt; p;
-    typename boost::graph_traits&lt;G&gt;::vertex_descriptor u, v;
-    typename boost::graph_traits&lt;G&gt;::vertex_property_type vp;
-    typename boost::graph_traits&lt;G&gt;::edge_property_type ep;
-  };
-</PRE>
-
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../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/PropertyGraph.html

@@ -1,213 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>PropertyGraph</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H2><A NAME="concept:PropertyGraph"></A>
-PropertyGraph
-</H2>
-
-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
-function which returns a property map object.
-
-<P>
-
-<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 PropertyGraph.</TD>
-</TR>
-
-<TR>
-<TD><tt>g</tt></TD>
-<TD>An object of type <tt>G</tt>.</TD>
-</TR>
-
-<TR>
-<TD><tt>X</tt></TD>
-<TD>Either the vertex or edge descriptor type for <tt>G</tt>.</TD>
-</TR>
-
-<TR>
-<TD><tt>x</tt></TD>
-<TD>An object of type <tt>X</tt>.</TD>
-</TR>
-
-
-<TR>
-<TD><tt>Map</tt></TD>
-<TD>The type <tt>boost::property_map&lt;G, Property&gt;::const_type</tt>.</TD>
-</TR>
-
-<TR>
-<TD><tt>v</tt></TD>
-<TD>An object of type <tt>boost::property_traits&lt;Map&gt;::value_type</tt>.</TD>
-</TR>
-
-<TR>
-<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>PropertyTag</tt>.</td>
-</TR>
-
-<TR>
-<TD><tt>pmap</tt></TD>
-<TD>An object of type <tt>Map</tt>.</td>
-</TR>
-
-</table>
-
-<H3>Associated types</H3>
-
-<table border>
-
-<tr>
-<td><pre>boost::property_map&lt;G, PropertyTag&gt;::type</pre>
-The type of the property map for the property specified by
-<TT>PropertyTag</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.
-</td>
-</tr>
-
-<tr>
-<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>PropertyTag</TT>. This type must be a model of <a
-href="../../property_map/ReadablePropertyMap.html">ReadablePropertyMap</a>
-with a key type the same as the graph's vertex or edge descriptor type.
-</td>
-</tr>
-
-</table>
-
-<h3>Valid Expressions</h3>
-
-<table border>
-
-<tr>
-<td> <TT>get(p,&nbsp;g)</TT> </td>
-<td>
-Returns the property map for the property specified by the
-<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;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>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>
-<tt>get(get(p, g), x)</tt><br>
-Return type: <tt>boost::property_traits&lt;Map&gt;::value_type</tt>
-</td>
-</TR>
-
-<tr>
-<td> <TT>put(p,&nbsp;g,&nbsp;x,&nbsp;v)</TT> </td>
-<td>
-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>
-<tt>
-pmap = get(p, g);<br>
-put(pmap, x, v)
-</tt><br>
-Return type: <TT>void</TT>
-</td>
-</TR>
-
-
-</TABLE>
-
-<H3>Complexity</H3>
-
-The <tt>get()</tt> property map function must be constant time.
-
-
-<H3>Models</H3>
-
-
-<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>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 PropertyTag&gt;
-  struct PropertyGraphConcept
-  {
-    typedef typename property_map&lt;G, PropertyTag&gt;::type Map;
-    typedef typename property_map&lt;G, PropertyTag&gt;::const_type const_Map;
-    void constraints() {
-      function_requires&lt; GraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; ReadWritePropertyMapConcept&lt;Map, X&gt; &gt;();
-      function_requires&lt; ReadablePropertyMapConcept&lt;const_Map, X&gt; &gt;();
-
-      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(PropertyTag(), g);
-      pval = get(PropertyTag(), g, x);
-      ignore_unused_variable_warning(pmap);
-    }
-    G g;
-    X x;
-    typename property_traits&lt;Map&gt;::value_type pval;
-  };
-</PRE>
-
-
-<h3>See Also</h3>
-
-<a href="./property_map.html"><tt>property_map</tt></a>
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../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/PropertyTag.html

@@ -1,121 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Property</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     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.sgi.com/tech/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/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="../../../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/VertexAndEdgeListGraph.html

@@ -1,74 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>VertexAndEdgeListGraph</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-
-<H2><A NAME="concept:VertexAndEdgeListGraph"></A>
-VertexAndEdgeListGraph
-</H2>
-
-The VertexAndEdgeListGraph concept refines the <a
-href="./VertexListGraph.html">VertexListGraph</a> and the <a
-href="./EdgeListGraph.html">EdgeListGraph</a> concepts. No further
-requirements are added.
-
-<H3>Refinement of</H3>
-
-<a href="./VertexListGraph.html">VertexListGraph</a>, 
-<a href="./EdgeListGraph.html">EdgeListGraph</a>
-
-
-<H3>Models</H3>
-
-<UL>
-<LI><TT>adjacency_list</TT></LI>
-</UL>
-
-<P>
-
-<H3>See Also</H3>
-
-<a href="./graph_concepts.html">Graph concepts</a>
-
-<H3>Concept Checking Class</H3>
-
-<P>
-<PRE>
-  template &lt;class G&gt;
-  struct VertexAndEdgeListGraph
-  {
-    void constraints() {
-      function_requires&lt; VertexListGraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; EdgeListGraphConcept&lt;G&gt; &gt;();
-    }
-  };
-</PRE>
-
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../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/VertexListGraph.html

@@ -1,153 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>VertexListGraph</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-
-<H2><A NAME="concept:VertexListGraph">
-VertexListGraph
-</H2>
-
-The <I>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.
-
-<H3>Refinement of</H3>
-
-<a href="./IncidenceGraph.html">IncidenceGraph</a>
-and <a href="./AdjacencyGraph.html">AdjacencyGraph</a>
-
-<H3>Associated Types</H3>
-
-<Table border>
-
-<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
-to all of the vertices in a graph.  A vertex iterator type must meet
-the requirements of <a
-href="../../utility/MultiPassInputIterator.html">MultiPassInputIterator</a>. The
-value type of the vertex iterator must be the vertex descriptor of the
-graph.
-</TD>
-</TR>
-
-<tr>
-<td><tt>boost::graph_traits&lt;G&gt;::vertices_size_type</tt><br><br>
-The unsigned integer type used to represent the number of vertices
-in the graph.
-</td>
-</tr>
-
-</table>
-
-<h3>Valid Expressions</h3>
-
-<table border>
-
-<tr>
-<th>Name</th><th>Expression</th><th>Return Type</th><th>Description</th>
-</tr>
-
-<tr>
-<td>Vertex Set of the Graph</td>
-<td><a name="sec:vertices"><TT>vertices(g)</TT></a></TD>
-<TD><TT>std::pair&lt;vertex_iterator,&nbsp;vertex_iterator&gt;</TT></TD>
-<TD>
-Returns an iterator-range providing access to all the vertices in the
-graph<TT>g</TT>.
-</TD>
-</TR>
-
-<tr>
-<td>Number of Vertices in the Graph </td>
-<td><TT>num_vertices(g)</TT></TD>
-<TD><TT>vertices_size_type</TT></TD>
-<TD>Returns the number of vertices in the graph <TT>g</TT>.</TD>
-</TR>
-
-</TABLE>
-
-
-<H3>Complexity guarantees</H3>
-
-<P>
-The <TT>vertices()</TT> function must return in constant time.
-
-<H3>See Also</H3>
-
-<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 VertexListGraphConcept
-  {
-    typedef typename boost::graph_traits&lt;G&gt;::vertex_iterator 
-      vertex_iterator;
-    void constraints() {
-      function_requires&lt; IncidenceGraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; AdjacencyGraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; MultiPassInputIteratorConcept&lt;vertex_iterator&gt; &gt;();
-
-      p = vertices(g);
-      V = num_vertices(g);
-      v = *p.first;
-      const_constraints(g);
-    }
-    void const_constraints(const G&amp; g) {
-      p = vertices(g);
-      V = num_vertices(g);
-      v = *p.first;
-    }
-    std::pair&lt;vertex_iterator, vertex_iterator&gt; p;
-    typename boost::graph_traits&lt;G&gt;::vertex_descriptor v;
-    typename boost::graph_traits&lt;G&gt;::vertices_size_type V;
-    G g;
-  };
-</PRE>
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../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/VertexMutableGraph.html

@@ -1,87 +0,0 @@
-<HTML>
-<!--
-  -- 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.
-  -->
-<Head>
-<Title>Vertex Mutable Graph</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     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.sgi.com/tech/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="../../../people/jeremy_siek.htm">Jeremy Siek</A>, Indiana University (<A HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)
-<A HREF="../../../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,80 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: Acknowledgements</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-
-<h1>Acknowledgements</h1>
-
-We owe many debts of thanks to a number of individuals who both
-inspired and encouraged us in developing the Boost Graph Library.
-
-<p>
-A most profound thanks goes to Alexander Stepanov for his pioneering
-work in generic programming, for his encouragement, and for his
-algorithm contributions to the BGL.  We thank Matthew Austern for his
-work on documenting the concepts of STL which provided a foundation
-for creating the concepts in the BGL. We thank Dietmar K&uuml;hl for
-his work on generic graph algorithms and design patterns; especially
-for the property map abstraction.
-
-<p>
-Dave Abrahams, Jens Maurer, Beman Dawes, Gary Powell, Greg Colvin,
-Valentin Bonnard, and the rest of the group at Boost provided valuable
-input to the BGL interface, numerous suggestions for improvement,
-proof reads of the documentation, and help with polishing the code.  A
-special thanks to Dave Abrahams for managing the formal review.
-
-<p>
-We also thank the following BGL users whose questions helped to
-improve the BGL: Gordon Woodhull, Dave Longhorn, Joel Phillips, and
-Edward Luke.
-
-<p>
-A special thanks to Jeffrey Squyres for editing and proof reading
-of the documentation.
-
-<p>
-Our original work on the Boost Graph Library was supported in part by
-NSF grant ACI-9982205 and by the Director, Office of Science, Division
-of Mathematical, Information, and Computational Sciences of the U.S.
-Department of Energy under contract number DE-AC03-76SF00098.
-<p>
-In our work we also used resources of the National Energy Research
-Scientific Computing Center, which is supported by the Office of
-Science of the U.S. Department of Energy.
-
-
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/adjacency_iterator.html

@@ -1,129 +0,0 @@
-<html>
-
-<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="../../../c++boost.gif" alt="c++boost.gif (8819 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="../../utility/iterator_adaptors.htm#iterator_adaptor">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.sgi.com/tech/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)
-</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,162 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: Graph Traits</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1><A NAME=""></A>
-<pre>
-adjacency_list_traits&lt;EdgeList, VertexList, Directed&gt;
-</pre>
-</H1>
-
-This class provides an alternate method for accessing some of the
-associated types of the <tt>adjacency_list</tt> class. The main reason
-for this class is that sometimes one would like to create graph
-properties whose values are vertex or edge descriptors. If you try to
-use <tt>graph_traits</tt> for this you will run into a problem with
-mutually recursive types. To get around this problem, the
-<tt>adjacency_list_traits</tt> class is provided, which gives the user
-access to the vertex and edge descriptor types without requiring the
-user to provide the property types for the graph.
-
-<pre>
-  template &lt;class EdgeList, class VertexList, class Directed&gt;
-  struct adjacency_list_traits {
-    typedef ... vertex_descriptor;
-    typedef ... edge_descriptor;
-    typedef ... directed_category;
-    typedef ... edge_parallel_category;
-  };
-</pre>
-
-<h3>Where Defined</h3>
-
-<a href="../../../boost/graph/adjacency_list.hpp"><tt>boost/graph/adjacency_list.hpp</tt></a>
-
-<H3>Template Parameters</H3>
-
-<P>
-<TABLE border>
-<TR>
-<th>Parameter</th><th>Description</th><th>Default</th>
-</tr>
-
-<TR><TD><TT>EdgeList</TT></TD>
-<TD>
-The selector type for the edge container implementation.
-</TD>
-<td><tt>vecS</tt></td>
-</TR>
-
-<TR><TD><TT>VertexList</TT></TD>
-<TD>
-The selector type for the vertex container implementation.
-</TD>
-<td><tt>vecS</tt></td>
-</TR>
-
-<TR><TD><TT>Directed</TT></TD>
-<TD>
-The selector type whether the graph is directed or undirected.
-</TD>
-<td><tt>directedS</tt></td>
-</TR>
-
-</table>
-
-<h3>Model of</h3>
-
-<a
-href="http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a> and
-<a href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>
-
-<h3>Type Requirements</h3>
-
-Under construction.
-
-<H2>Members</H2>
-
-<p>
-
-<table border>
-<tr>
-<th>Member</th><th>Description</th>
-</tr>
-
-<tr>
-<td><tt>
-vertex_descriptor
-</tt></td>
-<td>
-The type for the objects used to identify vertices in the graph.
-</td>
-</tr>
-
-<tr>
-<td><tt>
-edge_descriptor
-</tt></td>
-<td>
-The type for the objects used to identify edges in the graph.
-</td>
-</tr>
-
-<tr>
-<td><tt>
-directed_category
-</tt></td>
-<td>
-This says whether the graph is undirected (<tt>undirected_tag</tt>)
-or directed (<tt>directed_tag</tt>).
-</td>
-</tr>
-
-<tr>
-<td><tt>
-edge_parallel_category
-</tt></td>
-<td>
-This says whether the graph allows parallel edges to be inserted
-(<tt>allow_parallel_edge_tag</tt>) or if it automatically removes
-parallel edges (<tt>disallow_parallel_edge_tag</tt>).
-</td>
-</tr>
-
-</table>
-
-<h3>See Also</h3>
-
-<a href="./adjacency_list.html"><tt>adjacency_list</tt></a>
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/adjacency_matrix.html

@@ -1,551 +0,0 @@
-<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.  Jeremy Siek makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
-  -->
-<Head>
-<Title>Boost Graph Library: Adjacency Matrix</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     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><A NAME="1509"></A>
-<TABLE>
-<CAPTION ALIGN="BOTTOM"><STRONG>Figure 1:</STRONG> Adjacency Matrix Representation of a Directed Graph.</CAPTION>
-<TR><TD><IMG SRC="./figs/adj-matrix-graph.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 via the the property template parameters. See Section XXX for an
-explanation of how to use internal properties.
-
-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><A NAME="1509"></A>
-<TABLE>
-<CAPTION ALIGN="BOTTOM"><STRONG>Figure 1:</STRONG> Adjacency Matrix Representation of an Undirected Graph.</CAPTION>
-<TR><TD><IMG SRC="./figs/undir-adj-matrix-graph.gif" width="260" height="240"></TD>
-<TD><IMG SRC="./figs/undir-adj-matrix.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="./AdjacencyMatrix.html">AdjacencyMatrix</a>, and <a
-href="./MutablePropertyGraph.html">MutablePropertyGraph</a>.
-
-
-<h3>Associates 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.sgi.com/tech/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;::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</i>.<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</i>.<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</i> in graph <tt>g</i>.<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</i> in graph <tt>g</i>. If the graph is undirected,
-this iterator-range provides access to all edge incident on
-vertex <tt>v</i>. <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</i>.<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</i>.<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</i>.<br>
-(Required by <a href="IncidenceGraph.html">IncidenceGraph</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</i>.<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</i> to vertex <tt>v</i> in graph <tt>g</i>.<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)</i> 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)</i> 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)</i> 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</i>. 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;
-  typenamae 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/antora.yml

@@ -0,0 +1,10 @@
+name: graph
+version: ~
+title: Boost.Graph
+start_page: index.adoc
+asciidoc:
+  attributes:
+    source-language: cpp@
+    table-caption: false
+nav:
+  - modules/ROOT/nav.adoc

doc/awpaper.sty

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

doc/bandwidth.html

@@ -1,97 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: Bandwidth</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     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 an undirected 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 an undirected 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="../../../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_ford_shortest.html

@@ -1,312 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Bellman Ford Shortest Paths</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-
-<H1><A NAME="sec:bellman-ford"></A>
-<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(EdgeListGraph&amp; g, Size N, 
-  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.sgi.com/tech/stl/BinaryFunction.html">BinaryFunction</a>, class <a href="http://www.sgi.com/tech/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. 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>)
-  <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>
-
-initialize vertex <i>u</i> 
-
-
-
-
-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 there own
-custom-made visitor that can takes actions during 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>.
-</blockquote>
-
-IN: <tt>Size N</tt>
-<blockquote>
-  The number of vertices in the graph. The type <tt>Size</tt> must
-  be an integer type.
-</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/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>
-</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/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>
-</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/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.sgi.com/tech/stl/LessThanComparable.html"> Less
-  Than Comparable</a>.<br> <b>Default:</b> <tt>get(vertex_distance,
-  g)</tt>
-</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>
-</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>.
-</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>.
-</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="../../../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,115 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: bellman_visitor</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1>
-<pre>
-bellman_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="./BellmanFordVisitor.html">BellmanFordVisitor</a>.
-
-
-<h3>Example</h3>
-
-
-<h3>Model of</h3>
-
-<a href="./BellmanFordVisitor.html">BellmanFordVisitor</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/bellman_ford_shortest_paths.hpp">
-<TT>boost/graph/bellman_ford_shortest_paths.hpp</TT></a>
-
-<h3>Member Functions</h3>
-
-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.
-
-<h3>Non-Member Functions</h3>
-
-<table border>
-<tr>
-<th>Function</th><th>Description</th>
-</tr>
-
-<tr><td><tt>
-template &lt;class EventVisitorList&gt;<br>
-bellman_visitor&lt;EventVisitorList&gt;<br>
-make_bellman_visitor(EventVisitorList ev_list);
-</tt></td><td>
-Returns the event visitor list adapted to be a BellmanFordVisitor.
-</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="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/bfs_visitor.html

@@ -1,132 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: bfs_visitor</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1>
-<pre>
-bfs_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="./BFSVisitor.html">BFSVisitor</a>.
-
-
-<h3>Example</h3>
-
-This is an excerpt from <a
-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
-visitor.
-
-<pre>
-  // Construct graph G and obtain the source vertex s ...
-
-  boost::breadth_first_search(G, s, 
-   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()),
-                   copy_graph(G_copy, boost::on_examine_edge())))) );
-</pre>
-
-
-<h3>Model of</h3>
-
-<a href="./BFSVisitor.html">BFSVisitor</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><a href="./null_visitor.html"><tt>null_visitor</tt></a></TD>
-</TR>
-
-</table>
-
-<H3>Where Defined</H3>
-
-<P>
-<a href="../../../boost/graph/breadth_first_search.hpp">
-<TT>boost/graph/breadth_first_search.hpp</TT></a>
-
-<h3>Member Functions</h3>
-
-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.
-
-<h3>Non-Member Functions</h3>
-
-<table border>
-<tr>
-<th>Function</th><th>Description</th>
-</tr>
-
-<tr><td><tt>
-template &lt;class EventVisitorList&gt;<br>
-bfs_visitor&lt;EventVisitorList&gt;<br>
-make_bfs_visitor(EventVisitorList ev_list);
-</tt></td><td>
-Returns the event visitor list adapted to be a BFS 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="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/bgl_named_params.html

@@ -1,100 +0,0 @@
-<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.  Jeremy Siek makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
-  -->
-<Head>
-<Title>Boost Graph Library: Named Parameters</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     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="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML>

doc/bibliography.html

@@ -1,346 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: Bibliography</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     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.
-
-</DL>
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../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.w

@@ -1,386 +0,0 @@
-\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
-@{
-function_requires< VertexListGraphConcept<Graph> >();
-function_requires< IncidenceGraphConcept<Graph> >();
-function_requires< WritablePropertyMapConcept<ComponentMap, edge_t> >();
-function_requires< ReadWritePropertyMapConcept<DiscoverTimeMap, vertex_t> >();
-function_requires< 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.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/breadth_first_search.html

@@ -1,319 +0,0 @@
-<HTML>
-<!--
-  -- Copyright (c) Jeremy Siek 2000, 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.
-  -->
-<Head>
-<Title>Boost Graph Library: Breadth-First Search</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1><A NAME="sec:bfs">
-<TT>breadth_first_search</TT>
-</H1>
-
-<P>
-<PRE>
-<i>// named paramter version</i>
-template &lt;class <a href="./VertexListGraph.html">VertexListGraph</a>, class P, class T, class R&gt;
-void breadth_first_search(VertexListGraph& G, 
-  typename graph_traits&lt;VertexListGraph&gt;::vertex_descriptor s, 
-  const bgl_named_params&lt;P, T, R&gt;&amp; params);
-
-<i>// non-named parameter version</i>
-template &lt;class VertexListGraph, class Buffer, class BFSVisitor, 
-	  class ColorMap&gt;
-void breadth_first_search(const VertexListGraph&amp; g, 
-   typename graph_traits&lt;VertexListGraph&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>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>
-
-IN: <tt>vertex_descriptor s</tt>
-<blockquote>
-  The source vertex where the search is started.
-</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>
-</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/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/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>
-
-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/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>
-</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.
-  <b>Default:</b> <tt>boost::queue</tt>
-</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
-5</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="../../../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

@@ -1,180 +0,0 @@
-<HTML>
-<!--
-  -- Copyright (c) Jeremy Siek 2000, 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.
-  -->
-<Head>
-<Title>Boost Graph Library: Breadth-First Visit</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1><A NAME="sec:bfv">
-<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>.
-</blockquote>
-
-IN: <tt>vertex_descriptor s</tt>
-<blockquote>
-  The source vertex where the search is started.
-</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>
-</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/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>
-</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>
-</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.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>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="../../../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/build_antora.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+#
+# 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)
+#
+# Official repository: https://github.com/boostorg/graph
+#
+# Picked up by boostorg/release-tools' build_docs/{linuxdocs.sh,macosdocs.sh,
+# windowsdocs.ps1} via auto-detection: presence of this file selects the
+# Antora build pipeline. Output lands in doc/build/site/.
+
+set -xe
+
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+cd "$SCRIPT_DIR"
+
+if [ $# -eq 0 ]; then
+  PLAYBOOK="playbook.yml"
+else
+  PLAYBOOK="$1"
+fi
+
+echo "Installing npm dependencies..."
+npm ci
+
+echo "Building docs with Antora using $PLAYBOOK..."
+PATH="$(pwd)/node_modules/.bin:${PATH}"
+export PATH
+npx antora --clean --fetch "$PLAYBOOK"
+echo "Done"

doc/build_example_outputs.sh

@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+# Compiles every .cpp under modules/ROOT/examples/ with -std=c++14, runs it,
+# and writes stdout to a sibling .txt file that Antora pages can include.
+#
+# Usage:
+#   BOOST_INCLUDE=/path/to/boost/include \
+#   BOOST_LIB=/path/to/boost/lib       \
+#   ./build_example_outputs.sh
+#
+# Defaults below match the Conan-installed Boost 1.79 layout used for
+# local development. CI overrides them.
+
+set -u
+
+HERE=$(cd "$(dirname "$0")" && pwd)
+REPO_ROOT=$(cd "$HERE/.." && pwd)
+EXAMPLES_ROOT="$HERE/modules/ROOT/examples"
+
+: "${BOOST_INCLUDE:=$HOME/.conan/data/boost/1.79.0/_/_/package/2c7a64ca03ffe00ac4600bf373ea3ecf338b36d9/include}"
+: "${BOOST_LIB:=}"
+: "${CXX:=g++}"
+: "${CXXFLAGS:=-std=c++14 -O1 -w}"
+
+if [ ! -d "$BOOST_INCLUDE" ]; then
+    echo "BOOST_INCLUDE not found: $BOOST_INCLUDE" >&2
+    echo "Set BOOST_INCLUDE to the Boost include directory and re-run." >&2
+    exit 1
+fi
+
+# Per-example link flags. A handful of examples need the prebuilt
+# boost_graph library (graphviz, graphml readers and the isomorphism
+# example pull in non-header-only code).
+extra_libs_for() {
+    case "$1" in
+        io/graphml.cpp|io/graphviz.cpp|algorithms/isomorphism/isomorphism.cpp)
+            echo "-lboost_graph"
+            ;;
+        *)
+            echo ""
+            ;;
+    esac
+}
+
+LDFLAGS=""
+if [ -n "$BOOST_LIB" ]; then
+    LDFLAGS="-L$BOOST_LIB -Wl,-rpath,$BOOST_LIB"
+fi
+
+WORK=$(mktemp -d)
+trap 'rm -rf "$WORK"' EXIT
+
+ok=0
+fail=0
+fail_list=""
+
+while IFS= read -r src; do
+    rel=${src#"$EXAMPLES_ROOT/"}
+    out_txt=${src%.cpp}.txt
+    bin="$WORK/$(basename "$src" .cpp).out"
+    extra=$(extra_libs_for "$rel")
+
+    if ! "$CXX" $CXXFLAGS \
+            -I"$REPO_ROOT/include" -I"$BOOST_INCLUDE" \
+            "$src" -o "$bin" $LDFLAGS $extra 2>/dev/null; then
+        printf '  [compile FAIL] %s\n' "$rel"
+        fail=$((fail + 1))
+        fail_list+="$rel (compile)\n"
+        continue
+    fi
+
+    if ! "$bin" > "$out_txt.tmp" 2>&1; then
+        printf '  [run FAIL]     %s\n' "$rel"
+        rm -f "$out_txt.tmp"
+        fail=$((fail + 1))
+        fail_list+="$rel (run)\n"
+        continue
+    fi
+
+    mv "$out_txt.tmp" "$out_txt"
+    printf '  [OK]           %s\n' "$rel"
+    ok=$((ok + 1))
+done < <(find "$EXAMPLES_ROOT" -name '*.cpp' | sort)
+
+echo
+echo "Generated $ok .txt outputs, $fail failures."
+if [ "$fail" -gt 0 ]; then
+    printf "Failing examples:\n$fail_list"
+    exit 1
+fi

doc/challenge.html

@@ -1,122 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Challenge</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-
-<h2>Boost Graph Library Challenge and To-Do Items</h2>
-
-
-<ul>
-
-<li>Dynamic graph algorithms such as described in <a
-href="http://citeseer.nj.nec.com/eppstein99dynamic.html">Dynamic Graph
-Algorithms</a> and <a
-href="http://citeseer.nj.nec.com/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>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>disjoint_sets</tt> </li>
-  </ul>
-
-<li>Construct a set of planar graph algorithms.</li>
-  <ul>
-   <li> Is the graph planar?</li>
-   <li> &quot;Walk around the block&quot; and similar open and closed neighborhood 
-traversals. Note that edge traversals need to resolve to particular ends 
-and sides (see below), not just to the edge as a whole.</li>
-   <li> Given a point, find the nearest vertex, edge, or bounded polygon. 
-Again, edges are viewed as having left and right sides.</li>
-   <li> Given a line segment, find intersecting vertices, edges, or bounded 
-polygons.</li>
-   <li> Given a polygon, find intersecting whatever...</li>
-   <li> Various minimum bounding rectangle and clipping problems.</li>
-   <li> Construct a planar embedding of a planar graph.</li>
-   <li> Find a balanced separator of a graph.</li>
-   <li> Modify adjacency_list so that the out-edges can be ordered
-    according to a user defined comparison object.</li>
-  </ul>
-
-<li>Floyd-Warshall 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.geom.umn.edu/locate/qhull">Qhull</a> computes the
-convex hull, Delaunay triangulation, Voronoi diagram, and halfspace
-intersection about a point.  Qhull runs in 2-d, 3-d, 4-d, and higher
-dimensions.  Qhull is used for collision detection, animation, plate
-tectonics, 3-d modeling, robot motion planning, and other <a
-href="http://www.geom.umn.edu/~bradb/qhull-news.html#use">applications</a>.
-It is currently difficult to use from a C++ program.
-
-</li>
-
-
-<li>Explore the use of Algorithm Objects as an alternative to
-  the current approach with visitors.</li>
-
-<li>Analyze the algorithms that do not yet have visitors, and
-  come up with visitor interfaces for them.</li>
-
-<li>Add a check in the adjacency_list class to make sure
-  all the vertex property template arguments have kind=vertex_property_tag
-  and all edge property template arguments have kind=edge_property_tag.</li>
-
-<li>Clean up the output functions in graph_utility.hpp to
-  use streams, and document all the utility functions. Replace
-  the random number stuff with calls to the boost random number generator.</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 up the examples from Knuth's <i>Stanford GraphBase</i> using
-  the BGL. The file <a
-  href="../example/miles_span.cpp"><tt>examples/miles_span.cpp</tt></a>
-  is a start.
-
-<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.
-
-</ul>
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../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/connected_components.html

@@ -1,147 +0,0 @@
-<HTML>
-<!--
-  -- Copyright (c) Jeremy Siek 2000-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.  Jeremy Siek makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
-  -->
-<Head>
-<Title>Boost Graph Library: Connected Components</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-
-<H1>
-<A NAME="sec:connected-components">
-<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>.
-</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/WritablePropertyMap.html">Writable Property
-Map</a>. The value type shouch 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.
-</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/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/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>
-
-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/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>
-</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="../../../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,187 +0,0 @@
-<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.
-  -->
-<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" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1>Constructing graph algorithms with BGL</H1>
-
-<P>
-The <I>main</I> goal of  BGL is not to provide a nice graph class, or
-to provide a comprehensive set of reusable graph algorithms (though
-these are goals). The main goal of BGL is to encourage others to
-write reusable graph algorithms. By reusable we mean maximally
-reusable.  Generic programming is a methodology for making algorithms
-maximally reusable, and in this section we will discuss how to apply
-generic programming to constructing graph algorithms.
-
-<P>
-To illustrate the generic programming process we will step though the
-construction of a graph coloring algorithm. The graph coloring problem
-(or more specifically, the vertex coloring problem) is to label each
-vertex in a graph <i>G</i> with a color such that no two adjacent
-vertices are labeled with the same color and such that the minimum
-number of colors are used. In general, the graph coloring problem is
-NP-complete, and therefore it is impossible to find an optimal
-solution in a reasonable amount of time. However, there are many
-algorithms that use heuristics to find colorings that are close to the
-minimum.
-
-<P>
-The particular algorithm we present here is based on the linear time
-<TT>SEQ</TT> subroutine that is used in the estimation of sparse
-Jacobian and Hessian matrices&nbsp;[<A
-HREF="bibliography.html#curtis74:_jacob">9</A>,<A
-HREF="bibliography.html#coleman84:_estim_jacob">7</A>,<A
-HREF="bibliography.html#coleman85:_algor">6</A>].  This algorithm
-visits all of the vertices in the graph according to the order defined
-by the input order. At each vertex the algorithm marks the colors of
-the adjacent vertices, and then chooses the smallest unmarked color
-for the color of the current vertex. If all of the colors are already
-marked, a new color is created.  A color is considered marked if its
-mark number is equal to the current vertex number. This saves the
-trouble of having to reset the marks for each vertex. The
-effectiveness of this algorithm is highly dependent on the input
-vertex order. There are several ordering algorithms, including the
-<I>largest-first</I>&nbsp;[<A HREF="bibliography.html#welsch67">31</A>],
-<I>smallest-last</I>&nbsp;[<a
-href="bibliography.html#matula72:_graph_theory_computing">29</a>], and
-<I>incidence degree</I>&nbsp;[<a
-href="bibliography.html#brelaz79:_new">32</a>] algorithms, which
-improve the effectiveness of this coloring algorithm.
-
-<P>
-The first decision to make when constructing a generic graph algorithm
-is to decide what graph operations are necessary for implementing the
-algorithm, and which graph concepts the operations map to.  In this
-algorithm we will need to traverse through all of the vertices to
-intialize the vertex colors. We also need to access the adjacent
-vertices. Therefore, we will choose the <a
-href="./VertexListGraph.html">VertexListGraph</a> concept because it
-is the minimum concept that includes these operations.  The graph type
-will be parameterized in the template function for this algorithm. We
-do not restrict the graph type to a particular graph class, such as
-the BGL <a href="./adjacency_list.html"><TT>adjacency_list</TT></a>,
-for this would drastically limit the reusability of the algorithm (as
-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
-<TT>function_requires()</TT> (see Section <A
-HREF="../../concept_check/concept_check.htm">Concept
-Checking</A> for more details about concept checking).
-
-<P>
-Next we need to think about what vertex or edge properties will be
-used in the algorithm. In this case, the only property is vertex
-color. The most flexible way to specify access to vertex color is to
-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
-<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
-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
-algorithm is the number of colors that were needed to color the graph,
-hence the return type of the function is the graph's
-<TT>vertices_size_type</TT>. The following code shows the interface for our
-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''.
-
-<P>
-<PRE>
-namespace boost {
-  template &lt;class VertexListGraph, class Order, class Color&gt;
-  typename graph_traits&lt;VertexListGraph&gt;::vertices_size_type
-  sequential_vertex_color_ting(const VertexListGraph&amp; G, 
-    Order order, Color color)
-  {
-    typedef graph_traits&lt;VertexListGraph&gt; GraphTraits;
-    typedef typename GraphTraits::vertex_descriptor vertex_descriptor;
-    typedef typename GraphTraits::vertices_size_type size_type;
-    typedef typename property_traits&lt;Color&gt;::value_type ColorType;
-    typedef typename property_traits&lt;Order&gt;::value_type OrderType;
-
-    function_requires&lt; VertexListGraphConcept&lt;VertexListGraph&gt; &gt;();
-    function_requires&lt; ReadWritePropertyMapConcept&lt;Color, vertex_descriptor&gt; &gt;();
-    function_requires&lt; IntegerConcept&lt;ColorType&gt; &gt;();
-    function_requires&lt; size_type, ReadablePropertyMapConcept&lt;Order&gt; &gt;();
-    typedef typename same_type&lt;OrderType, vertex_descriptor&gt;::type req_same;
-    
-    size_type max_color = 0;
-    const size_type V = num_vertices(G);
-    std::vector&lt;size_type&gt; 
-      mark(V, numeric_limits_max(max_color));
-    
-    typename GraphTraits::vertex_iterator v, vend;
-    for (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++) {
-      vertex_descriptor current = order[i];
-
-      // 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)
-        mark[color[*ai]] = i; 
-
-      // find the smallest color unused by the adjacent vertices
-      size_type smallest_color = 0;
-      while (smallest_color &lt; max_color &amp;&amp; mark[smallest_color] == i) 
-        ++smallest_color;
-
-      // if all the colors are used up, increase the number of colors
-      if (smallest_color == max_color)
-        ++max_color;
-
-      color[current] = smallest_color;
-    }
-    return max_color;
-  }
-} // namespace boost
-</PRE>
-
-<P>
-
-
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/copy_graph.html

@@ -1,116 +0,0 @@
-<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.  Jeremy Siek makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
-  -->
-<Head>
-<Title>Boost Graph Library: Copy Graph</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     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>const 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.sgi.com/tech/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.sgi.com/tech/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/ReadablePropertyMap.html">Readable Property
-Map</a> and must map the vertex descriptors of <tt>G</tt> to the
-integers from 0 to <tt>num_vertices(G)</tt>.<br>
-
-<b>Default:</b> <tt>get(vertex_index, G)</tt>
-</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/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="../../../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

@@ -1,182 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: Cuthill-Mckee Ordering</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1><A NAME="sec:bfs">
-<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(log(m)|E|)</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;
-  void 
-  cuthill_mckee_ordering(IncidenceGraph&amp; g,
-                         typename graph_traits&lt;Graph&gt;::vertex_descriptor s,
-                         OutputIterator inverse_permutation, 
-                         ColorMap color, DegreeMap degree)
-
-  (2)
-  template &lt;class VertexListGraph, class OutputIterator, 
-            class ColorMap, class DegreeMap&gt;
-  void 
-  cuthill_mckee_ordering(VertexListGraph&amp; G, 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: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'' whereas version 2 finds a good starting vertex using the
-pseudo-peripheral pair heuristic. The choice of the ``starting
-vertex'' can have a significant effect on the quality of the ordering.
-
-<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.
-
-<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.
-
-<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.
-
-<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>.
-
-<li> <tt>vertex_descriptor s</tt> &nbsp(IN) <br>
-  The starting vertex.
-
-<li> <tt>OutputIterator inverse_permutation</tt> &nbsp(OUT) <br> 
-  The new vertex ordering. The vertices are written to the <a
-  href="http://www.sgi.com/tech/stl/OutputIterator.html">output
-  iterator</a> in their new order. 
-  
-<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).
-
-<li> <tt>DegreeMap degree_map</tt> &nbsp(IN) <br>
-  This must map vertices to their degree.
-
-</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>.
-
-<li> <tt><a href="http://www.sgi.com/tech/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.
-
-<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).
-
-<li> <tt>DegreeMap degree_map</tt> &nbsp(IN) <br>
-  This must map vertices to their degree.
-
-</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="../../../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/dag_shortest_paths.html

@@ -1,296 +0,0 @@
-<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.  Jeremy Siek makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
-  -->
-<Head>
-<Title>Boost Graph Library: Directed Acyclic Graph Shortest Paths</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1><A NAME="sec:dag_shortest_paths"></A>
-<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-path-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}.
-</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.
-</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/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>
-</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/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>
-</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/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>
-</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/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.sgi.com/tech/stl/StrictWeakOrdering.html">
-  StrictWeakOrdering</a> provided by the <tt>compare</tt> function
-  object.<br>
-  <b>Default:</b> <a
-  href="../../property_map/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.
-</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.sgi.com/tech/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>
-</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.sgi.com/tech/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>
-</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">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>
-</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/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/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>
-  
-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>
-</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="../../../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

@@ -1,308 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: Depth-First Search</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1><A NAME="sec:depth-first-search"></A>
-<TT>depth_first_search</TT>
-</H1>
-
-<P>
-<PRE>
-<i>// named parameter version</i>
-template &lt;class <a href="./VertexListGraph.html">VertexListGraph</a>, class class P, class T, class R&gt;
-void depth_first_search(VertexListGraph&amp; G,
-  const bgl_named_params&lt;P, T, R&gt;&amp; params);
-
-<i>// non-named parameter version</i>
-template &lt;class <a href="./VertexListGraph.html">VertexListGraph</a>, class <a href="DFSVisitor.html">DFSVisitor</a>, class ColorMap&gt;
-void depth_first_search(const VertexListGraph&amp; g, DFSVisitor vis, ColorMap color)
-
-template &lt;class <a href="./VertexListGraph.html">VertexListGraph</a>, class <a href="DFSVisitor.html">DFSVisitor</a>, class ColorMap&gt;
-void depth_first_search(const VertexListGraph&amp; g, DFSVisitor vis, ColorMap color, 
-                        typename graph_traits&lt;VertexListGraph&gt;::vertex_descriptor start)
-
-</PRE>
-
-<p>
-The <tt>depth_first_search()</tt> function performs a depth-first
-traversal of the vertices in a directed or undirected 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 indicated in by the triangles and 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>) 
- 
-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>
-  <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 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>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>
-
-
-<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>
-</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/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/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>
-
-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>
-</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/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>
-</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. 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.
-  
-<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_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>
-
-<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="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/depth_first_visit.html

@@ -1,115 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: Depth-First Visit</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H2><A NAME="sec:dfs"></A>
-<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 <a href="#ColorMap">ColorMap</a>&gt;
-void depth_first_visit(IncidenceGraph& g,
-  typename graph_traits&lt;IncidenceGraph&gt;::vertex_descriptor s, 
-  DFSVisitor&amp; vis, ColorMap color)
-</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>
-
-<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>. 
-</blockquote>
-
-IN: <tt>vertex_descriptor s</tt>
-<blockquote>
-  The source vertex from which to start the search.  
-</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>.
-</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/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>.
-</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="../../../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,115 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: dfs_visitor</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1>
-<pre>
-dfs_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="./DFSVisitor.html">DFSVisitor</a>.
-
-
-<h3>Example</h3>
-
-See the example for <a href="./EventVisitor.html">EventVisitor</a>.
-
-<h3>Model of</h3>
-
-<a href="./DFSVisitor.html">DFSVisitor</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/depth_first_search.hpp">
-<TT>boost/graph/depth_first_search.hpp</TT></a>
-
-<h3>Member Functions</h3>
-
-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.
-
-<h3>Non-Member Functions</h3>
-
-<table border>
-<tr>
-<th>Function</th><th>Description</th>
-</tr>
-
-<tr><td><tt>
-template &lt;class EventVisitorList&gt;<br>
-dfs_visitor&lt;EventVisitorList&gt;<br>
-make_dfs_visitor(EventVisitorList ev_list);
-</tt></td><td>
-Returns the event visitor list adapted to be a DFS 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="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/dijkstra_shortest_paths.html

@@ -1,405 +0,0 @@
-<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.  Jeremy Siek makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
-  -->
-<Head>
-<Title>Boost Graph Library: Dijkstra's Shortest Paths</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1><A NAME="sec:dijkstra"></A>
-<TT>dijkstra_shortest_paths</TT>
-</H1>
-
-
-<P>
-<PRE>
-<i>// named paramter version</i>
-template &lt;class <a href="./VertexListGraph.html">VertexListGraph</a>, class P, class T, class R&gt;
-void
-dijkstra_shortest_paths(VertexListGraph&amp; g,
-  typename graph_traits&lt;VertexListGraph&gt;::vertex_descriptor s,
-  const bgl_named_params&lt;P, T, R&gt;&amp; params);
-
-<i>// non-named parameter version</i>
-template &lt;class <a href="./VertexListGraph.html">VertexListGraph</a>, class <a href="DijkstraVisitor.html">DijkstraVisitor</a>, 
-	  class PredecessorMap, class DistanceMap,
-	  class WeightMap, class IndexMap, class <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Compare</a>, class <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">Combine</a>, 
-	  class DistInf, class DistZero&gt;
-void dijkstra_shortest_paths
-  (const VertexListGraph&amp; g,
-   typename graph_traits&lt;VertexListGraph&gt;::vertex_descriptor s, 
-   PredecessorMap predecessor, DistanceMap distance, WeightMap weight, 
-   IndexMap index_map,
-   Compare compare, Combine combine, DistInf inf, DistZero zero,
-   DijkstraVisitor vis)
-</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-path-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 there own
-custom-made visitor that can 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 you 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>
-    <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 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}.
-</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.
-</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/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>
-</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/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>
-</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/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>
-</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/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.sgi.com/tech/stl/StrictWeakOrdering.html">
-  StrictWeakOrdering</a> provided by the <tt>compare</tt> function
-  object.<br>
-  <b>Default:</b> <a
-  href="../../property_map/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.
-</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.sgi.com/tech/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>
-</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.sgi.com/tech/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>
-</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">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>
-</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/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/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>
-  
-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>
-</blockquote>
-
-
-<H3>Complexity</H3>
-
-<P>
-The time complexity is <i>O((V + E) log V)</i>, or just <i>O(E log V)</i>
-if all vertices are reachable from the source.
-
-<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 reacable 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>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="../../../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_visitor.html

@@ -1,129 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: dijkstra_visitor</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     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>'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>
-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="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/distance_recorder.html

@@ -1,186 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: distance_recorder</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1>
-<pre>
-distance_recorder&lt;DistanceMap, EventTag&gt;
-</pre>
-</H1>
-
-This is an <a href="./EventVisitor.html">EventVisitor</a> that records
-the distance of a vertex (using a <a
-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
-cannot be used with vertex events.
-
-<p>
-<tt>distance_recorder</tt> can be used with graph algorithms by
-wrapping it with the 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.
-
-<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>DistanceMap</TT></TD>
-<TD>
-A <a
-href="../../property_map/WritablePropertyMap.html">WritablePropertyMap</a>,
-where the key type and the value type are the vertex descriptor type
-of the graph.
-</TD>
-<TD>&nbsp;</TD>
-</TR>
-
-<TR><TD><TT>EventTag</TT></TD>
-<TD>
-The tag to specify when the <tt>distance_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>distance_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>
-distance_recorder(DistanceMap pa);
-</tt></td>
-<td>
-Construct a distance recorder object with distance 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 the distance of <i>v</i> as 
-one plus the distance of <i>u</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 DistanceMap, class Tag&gt;<br>
-distance_recorder&lt;DistanceMap, Tag&gt; <br>
-record_distances(DistanceMap pa, Tag);
-</tt></td><td>
-A convenient way to create a <tt>distance_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
- href="./distance_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>.
-
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 
-<!--  LocalWords:  DistanceMap EventTag EventVisitor map bfs dfs const Siek
- -->
-<!--  LocalWords:  EventVisitorList WritablePropertyMap Univ Quan
- -->
-<!--  LocalWords:  Lumsdaine
- -->

doc/edge_list.html

@@ -1,225 +0,0 @@
-<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.
-  -->
-<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" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-
-<H1><A NAME="sec:edge-list-class"></A>
-<PRE>
-edge_list&lt;EdgeIterator, ValueType, DiffType&gt;
-</PRE>
-</H1>
-
-<P>
-The <TT>edge_list</TT> class is an adaptor that turns a pair of edge
-iterators into a class that models <TT>EdgeListGraph</TT>. The
-<TT>value_type</TT> of the edge iterator must be a <TT>std::pair</TT> (or
-at least have <TT>first</TT> and <TT>second</TT> members). The
-<TT>first_type</TT> and <TT>second_type</TT> of the pair must be the
-same and they will be used for the graph's <TT>vertex_descriptor</TT>.
-The <TT>ValueType</TT> and <TT>DiffType</TT> template parameters are only
-needed if your compiler does not support partial
-specialization. Otherwise they default to the correct types.
-
-<P>
-
-<H3>Example</H3>
-
-<P>
-Applying the Bellman-Ford shortest paths algorithm to an
-<TT>edge_list</TT>.
-
-<P>
-<PRE>
-  enum { u, v, x, y, z, N };
-  char name[] = { 'u', 'v', 'x', 'y', 'z' };
-
-  typedef std::pair&lt;int,int&gt; E;
-  E edges[] = { E(u,y), E(u,x), E(u,v),
-                E(v,u),
-                E(x,y), E(x,v),
-                E(y,v), E(y,z),
-                E(z,u), E(z,x) };
-  
-  int weight[] = { -4, 8, 5,
-                   -2,
-                   9, -3,
-                   7, 2,
-                   6, 7 };
-
-  typedef boost::edge_list&lt;E*&gt; Graph;
-  Graph g(edges, edges + sizeof(edges) / sizeof(E));
-    
-  std::vector&lt;int&gt; distance(N, std::numeric_limits&lt;short&gt;::max());
-  std::vector&lt;int&gt; parent(N,-1);
-  
-  distance[z] = 0;
-  parent[z] = z;
-  bool r = boost::bellman_ford_shortest_paths(g, int(N), weight,
-                                              distance.begin(),
-                                              parent.begin());
-  if (r)  
-    for (int i = 0; i &lt; N; ++i)
-      std::cout &lt;&lt; name[i] &lt;&lt; ": " &lt;&lt; distance[i]
-                &lt;&lt; " " &lt;&lt; name[parent[i]] &lt;&lt; std::endl;
-  else
-    std::cout &lt;&lt; "negative cycle" &lt;&lt; std::endl;
-</PRE>
-The output is the distance from the root and the parent
-of each vertex in the shortest paths tree.
-<PRE>
-  u: 2 v
-  v: 4 x
-  x: 7 z
-  y: -2 u
-  z: 0 z
-</PRE>
-
-<P>
-<p>
-
-<H3>Where Defined</H3>
-
-<a href="../../../boost/graph/edge_list.hpp"><TT>boost/graph/edge_list.hpp</TT></a>
-
-<P>
-<H3>Template Parameters</H3>
-
-<P>
-<TABLE border>
-<TR>
-<th>Parameter</th><th>Description</th>
-</tr>
-
-<TR><TD><TT>EdgeIterator</TT></TD> <TD>Must be model of <a
-href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>
-who's <TT>value_type</TT> must be a pair of vertex descriptors.</TD>
-</TR>
-
-<TR><TD><TT>ValueType</TT></TD>
-<TD>The <TT>value_type</TT> of the <TT>EdgeIterator</TT>.<br>
-Default: <TT>std::iterator_traits&lt;EdgeIterator&gt;::value_type</TT></TD>
-</TR>
-
-<TR><TD><TT>DiffType</TT></TD>
-<TD>The <TT>difference_type</TT> of the <TT>EdgeIterator</TT>.<br>
-Default: <TT>std::iterator_traits&lt;EdgeIterator&gt;::difference_type</TT></TD>
-</TR>
-
-</TABLE>
-<P>
-
-<H3>Model of</H3>
-
-<a href="./EdgeListGraph.html">EdgeListGraph</a>
-
-<P>
-
-
-<H3>Associated Types</H3>
-
-<hr>
-
-<tt>boost::graph_traits&lt;edge_list&gt;::vertex_descriptor</tt>
-<br><br>
-The type for the vertex descriptors associated with the
-<TT>edge_list</TT>. This will be the same type as
-<TT>std::iterator_traits&lt;EdgeIterator&gt;::value_type::first_type</TT>.
-
-<hr>
-
-<tt>
-boost::graph_traits&lt;edge_list&gt;::edge_descriptor
-</tt>
-<br><br>
-The type for the edge descriptors associated with the
-<TT>edge_list</TT>. 
-
-<hr>
-
-<tt>
-boost::graph_traits&lt;edge_list&gt;::edge_iterator
-</tt>
-<br><br>
-The type for the iterators returned by <TT>edges()</TT>. The iterator
-category of the <TT>edge_iterator</TT> will be the same as that of the
-<TT>EdgeIterator</TT>.
-
-<hr>
-
-<h3>Member Functions</h3>
-
-<hr>
-
-<tt>
-edge_list(EdgeIterator first, EdgeIterator last)
-</tt>
-<br><br>
-Creates a graph object with <TT>n</TT> vertices and with the
-edges specified in the edge list given by the range <TT>[first,last)</TT>.
-
-<hr>
-
-<H3>Non-Member Functions</H3>
-
-<hr>
-
-<tt>
-std::pair&lt;edge_iterator, edge_iterator&gt;<br>
-edges(const edge_list&amp; g)
-</tt>
-<br><br>
-Returns an iterator-range providing access to the edge set of graph <TT>g</TT>.
-
-<hr>
-
-<tt>
-vertex_descriptor<br>
-source(edge_descriptor e, const edge_list&amp; g)
-</tt>
-<br><br>
-Returns the source vertex of edge <TT>e</TT>.
-
-<hr>
-
-<tt>
-vertex_descriptor<br>
-target(edge_descriptor e, const edge_list&amp; g)
-</tt>
-<br><br>
-Returns the target vertex of edge <TT>e</TT>.
-
-<hr>
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/edmunds_karp_max_flow.html

@@ -1,244 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: Edmunds-Karp Maximum Flow</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1><A NAME="sec:edmunds_karp_max_flow">
-<TT>edmunds_karp_max_flow</TT>
-</H1>
-
-<PRE>
-<i>// named paramter version</i>
-template &lt;class <a href="./VertexListGraph.html">VertexListGraph</a>, class P, class T, class R&gt;
-typename detail::edge_capacity_value&lt;VertexListGraph, P, T, R&gt;::value_type
-edmunds_karp_max_flow(VertexListGraph& g, 
-   typename graph_traits&lt;VertexListGraph&gt;::vertex_descriptor src,
-   typename graph_traits&lt;VertexListGraph&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="./VertexListGraph.html">VertexListGraph</a>, 
-	  class CapacityEdgeMap, class ResidualCapacityEdgeMap,
-	  class ReverseEdgeMap, class ColorMap, class PredEdgeMap&gt;
-typename property_traits&lt;CapacityEdgeMap&gt;::value_type
-edmunds_karp_max_flow(VertexListGraph&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>edmunds_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>
-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/edmunds_karp_max_flow.hpp"><TT>boost/graph/edmunds_karp_max_flow.hpp</TT></a>
-
-<P>
-
-<h3>Parameters</h3>
-
-IN: <tt>VertexListGraph&amp; g</tt>
-<blockquote>
-  A directed graph. The
-  graph's type must be a model of <a
-  href="./VertexListGraph.html">VertexListGraph</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/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/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/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/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/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/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/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/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>
-</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/edmunds-karp-eg.cpp"><tt>example/edmunds-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>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../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> 
-<!--  LocalWords:  HTML Siek Edmunds BGCOLOR ffffff ee VLINK ALINK ff IMG SRC
- -->
-<!--  LocalWords:  gif ALT BR sec edmunds 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

@@ -1,111 +0,0 @@
-// Boost.Graph library isomorphism test
-
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// 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.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 EXIT_SUCCESS;
-}

doc/faq.html

@@ -1,78 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: FAQ</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<h1>Frequently Asked Questions</h1>
-
-
-<ol>
-
-<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(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 & == 
- boost::detail::error_property_not_found &'
-</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>

doc/file_dependency_example.html

@@ -1,404 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>File Dependency Example</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-
-<H1><A NAME="sec:file-depend-eg"></A>
-File Dependency Example
-</H1>
-
-<P>
-One of the most common uses of the graph abstraction in computer
-science is to track dependencies. An example of dependency tracking
-that we deal with on a day to day basis is the compilation
-dependencies for files in programs that we write. These dependencies
-are used inside programs such as <TT>make</TT> or in an IDE such as
-Visual C++ to minimize the number of files that must be recompiled
-after some changes have been made.
-
-<P>
-<A HREF="#fig:file-dep">Figure 1</A> shows a graph that has a vertex
-for each source file, object file, and library that is used in the
-<TT>killerapp</TT> program. The edges in the graph show which files
-are used in creating other files. The choice of which direction to
-point the arrows is somewhat arbitrary. As long as we are consistent
-in remembering that the arrows mean ``used by'' then things will work
-out. The opposite direction would mean ``depends on''.
-
-<P>
-
-<P></P>
-<DIV ALIGN="CENTER"><A NAME="fig:file-dep"></A>
-<TABLE>
-<CAPTION ALIGN="BOTTOM"><STRONG>Figure 1:</STRONG>
-A graph representing file dependencies.</CAPTION>
-<TR><TD><IMG SRC="./figs/file_dep.gif" width="331" height="351"></TD></TR>
-</TABLE>
-</DIV><P></P>
-
-<P>
-A compilation system such as <TT>make</TT> has to be able to answer a
-number of questions:
-
-<P>
-
-<OL>
-<LI>If we need to compile (or recompile) all of the files, what order
-   should that be done it?
-</LI>
-<LI>What files can be compiled in parallel?
-</LI>
-<LI>If a file is changed, which files must be recompiled?
-</LI>
-<LI>Are there any cycles in the dependencies? (which means the user
-  has made a mistake and an error should be emitted)
-</LI>
-</OL>
-
-<P>
-In the following examples we will formulate each of these questions in
-terms of the dependency graph, and then find a graph algorithm to
-provide the solution. The graph in <A HREF="#fig:file-dep">Figure
-1</A> will be used in all of the following examples. The source code
-for this example can be found in the file <a
-href="../example/file_dependencies.cpp"><TT>examples/file_dependencies.cpp</TT></a>.
-
-<P>
-
-<H2>Graph Setup</H2>
-
-<P>
-Here we show the construction of the graph.  For simplicity we have
-constructed the graph &quot;by-hand&quot;. A compilation system such
-as <TT>make</TT> would instead parse a <TT>Makefile</TT> to get the
-list of files and to set-up the dependencies. We use the
-<TT>adjacency_list</TT> class to represent the graph. The
-<TT>vecS</TT> selector means that a <TT>std::vector</TT> will be used
-to represent each edge-list, which provides efficient traversal. The
-<TT>directedS</TT> selector means we want a directed graph, and the
-<TT>color_property</TT> attaches a color property to each vertex of the
-graph. The color property will be used in several of the algorithms in
-the following sections.
-
-<P>
-<PRE>
-  enum files_e { dax_h, yow_h, boz_h, zow_h, foo_cpp, 
-                 foo_o, bar_cpp, bar_o, libfoobar_a,
-                 zig_cpp, zig_o, zag_cpp, zag_o, 
-                 libzigzag_a, killerapp, N };
-  const char* name[] = { "dax.h", "yow.h", "boz.h", "zow.h", "foo.cpp",
-                         "foo.o", "bar.cpp", "bar.o", "libfoobar.a",
-                         "zig.cpp", "zig.o", "zag.cpp", "zag.o",
-                         "libzigzag.a", "killerapp" };
-
-  typedef std::pair&lt;int, int&gt; Edge;
-  Edge used_by[] = {
-    Edge(dax_h, foo_cpp), Edge(dax_h, bar_cpp), Edge(dax_h, yow_h),
-    Edge(yow_h, bar_cpp), Edge(yow_h, zag_cpp),
-    Edge(boz_h, bar_cpp), Edge(boz_h, zig_cpp), Edge(boz_h, zag_cpp),
-    Edge(zow_h, foo_cpp), 
-    Edge(foo_cpp, foo_o),
-    Edge(foo_o, libfoobar_a),
-    Edge(bar_cpp, bar_o),
-    Edge(bar_o, libfoobar_a),
-    Edge(libfoobar_a, libzigzag_a),
-    Edge(zig_cpp, zig_o),
-    Edge(zig_o, libzigzag_a),
-    Edge(zag_cpp, zag_o),
-    Edge(zag_o, libzigzag_a),
-    Edge(libzigzag_a, killerapp)
-  };
-
-  using namespace boost;
-  typedef adjacency_list&lt;vecS, vecS, directedS, 
-      property&lt;vertex_color_t, default_color_type&gt;,
-      property&lt;edge_weight_t, int&gt;
-    &gt; Graph;
-  Graph g(N, used_by, used_by + sizeof(used_by) / sizeof(Edge));
-  typedef graph_traits&lt;Graph&gt;::vertex_descriptor Vertex;
-</PRE>
-
-<P>
-
-<H2>Compilation Order (All Files)</H2>
-
-<P>
-On the first invocation of <TT>make</TT> for a particular project, all
-of the files must be compiled. Given the dependencies between the
-various files, what is the correct order in which to compile and link
-them? First we need to formulate this in terms of a graph. Finding a
-compilation order is the same as ordering the vertices in the graph.
-The constraint on the ordering is the file dependencies which we have
-represented as edges. So if there is an edge <i>(u,v)</i> in the graph
-then <i>v</i> better not come before <i>u</i> in the ordering. It
-turns out that this kind of constrained ordering is called a
-<I>topological sort</I>. Therefore, answering the question of
-compilation order is as easy as calling the BGL algorithm <a
-href="./topological_sort.html"><TT>topological_sort()</TT></a>. The
-traditional form of the output for topological sort is a linked-list
-of the sorted vertices.  The BGL algorithm instead puts the sorted
-vertices into any <a
-href="http://www.sgi.com/tech/stl/OutputIterator.html">OutputIterator</a>,
-which allows for much more flexibility.  Here we use the
-<TT>std::front_insert_iterator</TT> to create an output iterator that
-inserts the vertices on the front of a linked list.  Other possible
-options are writing the output to a file or inserting into a different
-STL or custom-made container.
-
-<P>
-<PRE>
-  typedef std::list&lt;Vertex&gt; MakeOrder;
-  MakeOrder make_order;
-  boost::topological_sort(g, std::front_inserter(make_order));
-    
-  std::cout &lt;&lt; "make ordering: ";
-  for (MakeOrder::iterator i = make_order.begin();
-       i != make_order.end(); ++i)
-    std::cout &lt;&lt; name[*i] &lt;&lt; " ";
-  std::cout &lt;&lt; std::endl;
-</PRE>
-The output of this is:
-<PRE>
-  make ordering: zow.h boz.h zig.cpp zig.o dax.h yow.h zag.cpp \
-  zag.o bar.cpp bar.o foo.cpp foo.o libfoobar.a libzigzag.a killerapp
-</PRE>
-
-<P>
-
-<H2><A NAME="sec:parallel-compilation"></A>
-Parallel Compilation
-</H2>
-
-<P>
-Another question the compilation system might need to answer is: what
-files can be compiled simultaneously? This would allow the system to
-spawn threads and utilize multiple processors to speed up the build.
-This question can also be put in a slightly different way: what is the
-earliest time that a file can be built assuming that an unlimited
-number of files can be built at the same time? The main criteria for
-when a file can be built is that all of the files it depends on must
-already be built. To simplify things for this example, we'll assume
-that each file takes 1 time unit to build (even header files). The
-main observation for determining the ``time slot'' for a file is that
-the time slot must be one more than the maximum time-slot of the files
-it depends on.
-
-<P>
-This idea of calculating a value based on the previously computed
-values of neighboring vertices is the same idea behind Dijkstra's
-single-source shortest paths algorithm (see <a
-href="./dijkstra_shortest_paths.html"><tt>dijkstra_shortest_paths()</tt></a>). The
-main difference between this situation and a shortest-path algorithm
-is that we want to use the maximum of the neighbors' values instead of
-the minimum.  In addition, we do not have a single source
-vertex. Instead we will want to treat all vertices with in-degree of
-zero as sources (i.e., vertices with no edges coming into them). So we
-use Dijkstra's algorithm with several extra parameters instead
-of relying on the defaults.
-
-<P>
-To use <TT>dijkstra_shortest_paths()</TT>, we must first set up the vertex
-and edge properties that will be used in the algorithm.  We will need
-a time property (replacing the distance property of Dijkstra's
-algorithm) and an edge weight property. We will use a
-<TT>std::vector</TT> to store the time. The weight property has already
-been attached to the graph via a plug-in so here we just declare an
-map for the internal weight property.
-
-<P>
-<PRE>
-  std::vector&lt;int&gt; time(N, 0);
-  typedef std::vector&lt;int&gt;::iterator Time;
-  using boost::edge_weight_t;
-  typedef boost::property_map&lt;Graph, edge_weight_t&gt;::type Weight;
-  Weight weight = get(edge_weight, g);
-</PRE>
-
-<P>
-The next step is to identify the vertices with zero in-degree which
-will be our ``source'' vertices from which to start the shortest path
-searches. The in-degrees can be calculated with the following loop.
-
-<P>
-<PRE>
-  std::vector&lt;int&gt; in_degree(N, 0);
-  Graph::vertex_iterator i, iend;
-  Graph::out_edge_iterator j, jend;
-  for (boost::tie(i, iend) = vertices(g); i != iend; ++i)
-    for (boost::tie(j, jend) = out_edges(*i, g); j != jend; ++j)
-      in_degree[target(*j, g)] += 1;
-</PRE>
-
-<P>
-Next we need to define comparison of the &quot;cost&quot;. In this
-case we want each file to have a time stamp greater than any of its
-predecessors.  Therefore we define comparison with the
-<TT>std::greater&lt;int&gt;</TT> function object.  We also need to
-tell the algorithm that we want to use addition to combine time
-values, so we use <TT>std::plus&lt;int&gt;</TT>.
-
-<P>
-<PRE>
-  std::greater&lt;int&gt; compare;
-  std::plus&lt;int&gt; combine;
-</PRE>
-
-<P>
-We are now ready to call <TT>uniform_cost_search()</TT>. We just
-loop through all the vertices in the graph, and invoke the algorithm
-if the vertex has zero in-degree.
-
-<P>
-<PRE>
-  for (boost::tie(i, iend) = vertices(g); i != iend; ++i)
-    if (in_degree[*i] == 0)
-      boost::dijkstra_shortest_paths(g, *i, 
-				     distance_map(&amp;time[0]). 
-				     weight_map(weight). 
-				     distance_compare(compare).
-				     distance_combine(combine));
-</PRE>
-
-<P>
-Last, we output the time-slot that we've calculated for each vertex.
-
-<P>
-<PRE>
-  std::cout &lt;&lt; "parallel make ordering, " &lt;&lt; std::endl
-       &lt;&lt; "  vertices with same group number" &lt;&lt; std::endl
-       &lt;&lt; "  can be made in parallel" &lt;&lt; std::endl &lt;&lt; std::endl;
-  for (boost::tie(i, iend) = vertices(g); i != iend; ++i)
-    std::cout &lt;&lt; "time_slot[" &lt;&lt; name[*i] &lt;&lt; "] = " &lt;&lt; time[*i] &lt;&lt; std::endl;
-</PRE>
-The output is:
-<PRE>
-  parallel make ordering, 
-    vertices with same group number 
-    can be made in parallel
-  time_slot[dax.h] = 0
-  time_slot[yow.h] = 1
-  time_slot[boz.h] = 0
-  time_slot[zow.h] = 0
-  time_slot[foo.cpp] = 1
-  time_slot[foo.o] = 2
-  time_slot[bar.cpp] = 2
-  time_slot[bar.o] = 3
-  time_slot[libfoobar.a] = 4
-  time_slot[zig.cpp] = 1
-  time_slot[zig.o] = 2
-  time_slot[zag.cpp] = 2
-  time_slot[zag.o] = 3
-  time_slot[libzigzag.a] = 5
-  time_slot[killerapp] = 6
-</PRE>
-
-<P>
-
-<H2><A NAME="SECTION001014000000000000000"></A>
-<A NAME="sec:cycles"></A>
-<BR>
-Cyclic Dependencies
-</H2>
-
-<P>
-Another question the compilation system needs to be able to answer is
-whether there are any cycles in the dependencies. If there are cycles,
-the system will need to report an error to the user so that the cycles
-can be removed. One easy way to detect a cycle is to run a <a
-href="./depth_first_search.html">depth-first search</a>, and if the
-search runs into an already discovered vertex (of the current search
-tree), then there is a cycle. An already discovered vertex will have
-been colored gray, so we can insert a check for this color in the
-depth-first search. The BGL graph search algorithms (which includes
-<TT>depth_first_search()</TT>) are all extensible via the
-<I>visitor</I> mechanism. A visitor is similar to a function object,
-but it has several methods instead of just the one
-<TT>operator()</TT>.  The visitor's methods are called at certain
-points within the algorithm, thereby giving the user a way to extend
-the functionality of the graph search algorithms. See Section <A
-HREF="visitor_concepts.html">Visitor Concepts</A>
-for a detailed description of visitors.
-
-<P>
-We will create a visitor class and fill in the <TT>back_edge()</TT>
-method, which is the <a href="./DFSVisitor.html">DFSVisitor</a> method
-that is called when DFS explores a new edge. This is the place where
-we want to place the color check which will determine whether there
-are cyclic dependencies.  Inheriting from <TT>dfs_visitor&lt;&gt;</TT>
-provides the visitor with empty versions of the other visitor methods.
-Once our visitor is created, we can construct and object and pass it
-to the BGL algorithm.  Visitor objects are passed by value inside of
-the BGL algorithms, so the <TT>has_cycle</TT> flag is stored by
-reference in this visitor.
-
-<P>
-<PRE>
-  template &lt;class Color&gt;
-  struct cycle_detector : public dfs_visitor&lt;&gt;
-  {
-    typedef typename boost::property_traits&lt;Color&gt;::value_type C;
-
-    cycle_detector(Color c, bool& has_cycle) 
-      : _has_cycle(has_cycle), color(c) { }
-
-    template &lt;class Edge, class Graph&gt;
-    void back_edge(Edge e, Graph& g) {
-      _has_cycle = true;
-    }
-  protected:
-    bool& _has_cycle;
-    Color color;
-  };
-</PRE>
-
-<P>
-We can now invoke the BGL <TT>depth_first_search()</TT>
-algorithm and pass in the cycle detector visitor.
-
-<P>
-<PRE>
-  bool has_cycle = false;
-  cycle_detector&lt;Color&gt; vis(color, has_cycle);
-  boost::depth_first_search(g, visitor(vis));
-  std::cout &lt;&lt; "The graph has a cycle? " &lt;&lt; has_cycle &lt;&lt; std::endl;
-</PRE>
-
-<P>
-The graph in <A HREF="#fig:file-dep">Figure 1</A> (ignoring the dotted
-line) did not have any cycles, but if we add a dependency between
-<TT>bar.cpp</TT> and <TT>dax.h</TT> there there will be. Such a
-dependency would be flagged as a user error.
-
-<P>
-<PRE>
-  add_edge(bar_cpp, dax_h, g);
-</PRE>
-
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../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/filtered_graph.html

@@ -1,511 +0,0 @@
-<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.  Jeremy Siek makes no
-  -- representations about the suitability of this software for any
-  -- purpose.  It is provided "as is" without express or implied warranty.
-  -->
-<Head>
-<Title>Boost Graph Library: Filtered Graph</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-
-
-<H1><A NAME="sec:filtered-graph-class"></A>
-<pre>
-filtered_graph&lt;Graph, EdgePredicate, VertexPredicate&gt;
-</pre>
-</H1>
-
-
-<P>
-The <tt>filtered_graph</tt> class template is an adaptor that creates
-a filtered view of a graph. The predicate function objects determine
-which edges and vertices of the original graph will show up in the
-filtered graph.  If the edge predicate returns <tt>true</tt> for an
-edge then it shows up in the filtered graph, and if the predicate
-returns <tt>false</tt> then the edge does not appear in the filtered
-graph.  Likewise for vertices. The <tt>filtered_graph</tt> class does
-not create a copy of the original graph, but uses a reference to the
-original graph. The lifetime of the original graph must extend past
-any use of the filtered graph. The filtered graph does not change the
-structure of the original graph, though vertex and edge properties of
-the original graph can be changed through property maps of the
-filtered graph. Vertex and edge descriptors of the filtered graph are
-the same as, and interchangeable with, the vertex and edge descriptors
-of the original graph.
-<P>
-
-<H3>Example</H3>
-
-<P>
-In this example we will filter a graph's edges based on edge
-weight. We will keep all edges with positive edge weight.
-First, we create a predicate function object.
-
-<PRE>
-template &lt;typename EdgeWeightMap&gt;
-struct positive_edge_weight {
-  positive_edge_weight() { }
-  positive_edge_weight(EdgeWeightMap weight) : m_weight(weight) { }
-  template &lt;typename Edge&gt;
-  bool operator()(const Edge& e) const {
-    return 0 &lt; get(m_weight, e);
-  }
-  EdgeWeightMap m_weight;
-};
-</PRE>
-
-Now we create a graph and print out the filtered graph.
-<pre>
-int main()
-{
-  using namespace boost;
-  
-  typedef adjacency_list&lt;vecS, vecS, directedS,
-    no_property, property&lt;edge_weight_t, int&gt; &gt; Graph;
-  typedef property_map&lt;Graph, edge_weight_t&gt;::type EdgeWeightMap;
-
-  enum { A, B, C, D, E, N };
-  const char* name = "ABCDE";
-  Graph g(N);
-  add_edge(A, B, 2, g);
-  add_edge(A, C, 0, g);
-  add_edge(C, D, 1, g);
-  add_edge(C, E, 0, g);
-  add_edge(D, B, 3, g);
-  add_edge(E, C, 0, g);
-  
-  positive_edge_weight&lt;EdgeWeightMap&gt; filter(get(edge_weight, g));
-  filtered_graph&lt;Graph, positive_edge_weight&lt;EdgeWeightMap&gt; &gt;
-    fg(g, filter);
-
-  std::cout &lt;&lt; "filtered edge set: ";
-  print_edges(fg, name);
-
-  std::cout &lt;&lt; "filtered out-edges:" &lt;&lt; std::endl;
-  print_graph(fg, name);
-  
-  return 0;
-}
-</pre>
-The output is:
-<PRE>
-filtered edge set: (A,B) (C,D) (D,B) 
-filtered out-edges:
-A --> B 
-B --> 
-C --> D 
-D --> B 
-E --> 
-</PRE>
-
-<P>
-
-<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 underlying graph type.</TD>
-<TD>&nbsp;</TD>
-</TR>
-
-<TR>
-<TD><TT>EdgePredicate</TT></TD> <TD>A function object that selects
-which edges from the original graph will appear in the filtered
-graph. The function object must model <a
-href="http://www.sgi.com/tech/stl/Predicate.html">Predicate</a>. The
-argument type for the function object must be the edge descriptor type
-of the graph. Also, the predicate must be <a
-href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default Constructible</a> <a href="#1">[1]</a>.</TD>
-<TD>&nbsp;</TD>
-</TR>
-
-<TR>
-<TD><TT>VertexPredicate</TT></TD>
-<TD>A function object that selects
-which vertices from the original graph will appear in the filtered
-graph. The function object must model <a
-href="http://www.sgi.com/tech/stl/Predicate.html">Predicate</a>. The
-argument type for the function object must be the vertex descriptor type
-of the graph. Also, the predicate must be <a
-href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default Constructible</a> <a href="#1">[1]</a>.</TD>
-<TD><TT>keep_all</TT></TD>
-</TR>
-
-</TABLE>
-<P>
-
-<H3>Model of</H3>
-
-<P>
-This depends on the underlying graph type. If the underlying
-<tt>Graph</tt> type models <a
-href="./VertexAndEdgeListGraph.html">VertexAndEdgeListGraph</a> and <a
-href="./PropertyGraph.html">PropertyGraph</a> then so does the
-filtered graph. If the underlying <tt>Graph</tt> type models fewer or
-smaller concepts than these, then so does the filtered graph.
-
-<P>
-
-<H3>Where Defined</H3>
-
-<P>
-<a href="../../../boost/graph/filtered_graph.hpp"><TT>boost/graph/filtered_graph.hpp</TT></a>
-
-<P>
-
-<H2>Associated Types</H2>
-
-<hr>
-
-<tt>graph_traits&lt;filtered_graph&gt;::vertex_descriptor</tt>
-<br><br>
-
-The type for the vertex descriptors associated with the
-<TT>filtered_graph</TT>, which is the same type as the
-<tt>vertex_descriptor</tt> for the original <tt>Graph</tt>.
-
-
-<hr>
-
-<tt>graph_traits&lt;filtered_graph&gt;::edge_descriptor</tt><br>
-<br><br>
-The type for the edge descriptors associated with the
-<TT>filtered_graph</TT>, which is the same type as the
-<tt>edge_descriptor</tt> for the original <tt>Graph</tt>.
-
-<hr>
-
-<tt>graph_traits&lt;filtered_graph&gt;::vertex_iterator</tt>
-<br><br>
-The type for the iterators returned by <TT>vertices()</TT>.
-The iterator is a model of <a href="../../utility/MultiPassInputIterator.html">MultiPassInputIterator</a>.
-
-
-<hr>
-
-<tt>graph_traits&lt;filtered_graph&gt;::edge_iterator</tt>
-<br><br>
-The type for the iterators returned by <TT>edges()</TT>.
-The iterator is a model of <a href="../../utility/MultiPassInputIterator.html">MultiPassInputIterator</a>.
-
-<hr>
-
-
-<tt>graph_traits&lt;filtered_graph&gt;::out_edge_iterator</tt>
-<br><br>
-The type for the iterators returned by <TT>out_edges()</TT>.
-The iterator is a model of <a href="../../utility/MultiPassInputIterator.html">MultiPassInputIterator</a>.
-
-
-<hr>
-
-<tt>graph_traits&lt;filtered_graph&gt;::adjacency_iterator</tt>
-<br><br>
-The type for the iterators returned by <TT>adjacent_vertices()</TT>.
-The <tt>adjacency_iterator</tt> models the same iterator concept as
-<tt>out_edge_iterator</tt>.
-
-<hr>
-
-<tt>graph_traits&lt;filtered_graph&gt;::directed_category</tt><br>
-<br><br>
-Provides information about whether the graph is directed
-(<TT>directed_tag</TT>) or undirected (<TT>undirected_tag</TT>).
-
-<hr>
-
-<tt>graph_traits&lt;filtered_graph&gt;::edge_parallel_category</tt><br>
-<br><br>
-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>.
-
-<hr>
-
-<tt>graph_traits&lt;filtered_graph&gt;::vertices_size_type</tt>
-<br><br>
-The type used for dealing with the number of vertices in the graph.
-
-<hr>
-
-<tt>graph_traits&lt;filtered_graph&gt;::edge_size_type</tt>
-<br><br>
-The type used for dealing with the number of edges in the graph.
-
-<hr>
-
-<tt>graph_traits&lt;filtered_graph&gt;::degree_size_type</tt>
-<br><br>
-The type used for dealing with the number of edges incident to a vertex
-in the graph.
-
-<hr>
-
-<tt>property_map&lt;filtered_graph, Property&gt;::type</tt><br>
-and<br>
-<tt>property_map&lt;filtered_graph, Property&gt;::const_type</tt>
-<br><br>
-The property map type for vertex or edge properties in the graph. 
-The same property maps from the adapted graph are available
-in the filtered graph.
-
-<hr>
-
-<H2>Member Functions</H2>
-
-<hr>
-
-<pre>
-filtered_graph(Graph&amp;&nbsp;g, EdgePredicate&nbsp;ep, VertexPredicate&nbsp;vp)
-</pre>
-Create a filtered graph based on the graph <i>g</i> and the
-edge filter <i>ep</i> and vertex filter <i>vp</i>.
-
-<hr>
-
-<pre>
-filtered_graph(Graph&amp;&nbsp;g, EdgePredicate&nbsp;ep)
-</pre>
-Create a filtered graph based on the graph <i>g</i> and the
-edge filter <i>ep</i>. All vertices from the original graph
-are retained.
-
-<hr>
-
-filtered_graph(const&nbsp;filtered_graph&amp;&nbsp;x)
-</pre>
-This creates a filtered graph for the same underlying graph
-as <i>x</i>. Anotherwords, this is a shallow copy.
-
-<hr>
-
-<pre>
-filtered_graph&amp; operator=(const&nbsp;filtered_graph&amp;&nbsp;x)
-</pre>
-This creates a filtered graph for the same underlying graph
-as <i>x</i>. Anotherwords, this is a shallow copy.
-
-<hr>
-
-<P>
-
-<H2>Non-Member Functions</H2>
-
-<h4>Structure Access</h4>
-
-<hr>
-
-<pre>
-std::pair&lt;vertex_iterator,&nbsp;vertex_iterator&gt;
-vertices(const filtered_graph&amp; g)
-</pre>
-Returns an iterator-range providing access to the vertex set of graph
-<tt>g</tt>.
-
-<hr>
-
-<pre>
-std::pair&lt;edge_iterator,&nbsp;edge_iterator&gt;
-edges(const filtered_graph&amp; g)
-</pre>
-Returns an iterator-range providing access to the edge set of graph
-<tt>g</tt>.
-
-<hr>
-
-<pre>
-std::pair&lt;adjacency_iterator,&nbsp;adjacency_iterator&gt;
-adjacent_vertices(vertex_descriptor&nbsp;u, const&nbsp;filtered_graph&amp;&nbsp;g)
-</pre>
-Returns an iterator-range providing access to the vertices adjacent to
-vertex <tt>u</tt> in graph <tt>g</tt>.
-
-<hr>
-
-
-<pre>
-std::pair&lt;out_edge_iterator,&nbsp;out_edge_iterator&gt;
-out_edges(vertex_descriptor&nbsp;u, const&nbsp;filtered_graph&amp;&nbsp;g)
-</pre>
-Returns an iterator-range providing access to the out-edges of vertex
-<tt>u</tt> in graph <tt>g</tt>. If the graph is undirected, this
-iterator-range provides access to all edges incident on vertex
-<tt>u</tt>. For both directed and undirected graphs, for an out-edge
-<tt>e</tt>, <tt>source(e, g) == u</tt> and <tt>target(e, g) == v</tt>
-where <tt>v</tt> is a vertex adjacent to <tt>u</tt>.
-
-<hr>
-
-<pre>
-std::pair&lt;in_edge_iterator,&nbsp;in_edge_iterator&gt;
-in_edges(vertex_descriptor&nbsp;v, const&nbsp;filtered_graph&amp;&nbsp;g)
-</pre>
-Returns an iterator-range providing access to the in-edges of vertex
-<tt>v</tt> in graph <tt>g</tt>.  For an in-edge <tt>e</tt>,
-<tt>target(e, g) == v</tt> and <tt>source(e, g) == u</tt> for some
-vertex <tt>u</tt> that is adjacent to <tt>v</tt>, whether the graph is
-directed or undirected.
-
-<hr>
-
-<pre>
-vertex_descriptor
-source(edge_descriptor&nbsp;e, const&nbsp;filtered_graph&amp;&nbsp;g)
-</pre>
-Returns the source vertex of edge <tt>e</tt>.
-
-<hr>
-
-<pre>
-vertex_descriptor
-target(edge_descriptor&nbsp;e, const&nbsp;filtered_graph&amp;&nbsp;g)
-</pre>
-Returns the target vertex of edge <tt>e</tt>.
-
-<hr>
-
-<pre>
-degree_size_type
-out_degree(vertex_descriptor&nbsp;u, const&nbsp;filtered_graph&amp;&nbsp;g)
-</pre>
-Returns the number of edges leaving vertex <tt>u</tt>.
-
-<hr>
-
-<pre>
-degree_size_type
-in_degree(vertex_descriptor&nbsp;u, const&nbsp;filtered_graph&amp;&nbsp;g)
-</pre>
-Returns the number of edges entering vertex <tt>u</tt>. 
-
-<hr>
-
-<pre>
-vertices_size_type
-num_vertices(const filtered_graph&amp; g)
-</pre>
-Returns the number of vertices in the underlying graph <a href="#2">[2]</a>. 
-
-<hr>
-
-<pre>
-edges_size_type
-num_edges(const filtered_graph&amp; g)
-</pre>
-Returns the number of edges in the graph <tt>g</tt>.
-
-<hr>
-
-<pre>
-std::pair&lt;edge_descriptor, bool&gt;
-edge(vertex_descriptor&nbsp;u, vertex_descriptor&nbsp;v,
-     const&nbsp;filtered_graph&amp;&nbsp;g)
-</pre>
-Returns the edge connecting vertex <tt>u</tt> to vertex <tt>v</tt> in
-graph <tt>g</tt>.
-
-<hr>
-
-<h4>Property Map Access</h4>
-
-<hr>
-
-<pre>
-template &lt;class <a href="./PropertyTag.html">PropertyTag</a>&gt;
-property_map&lt;filtered_graph, PropertyTag&gt;::type
-get(PropertyTag, filtered_graph&amp; g)
-
-template &lt;class <a href="./PropertyTag.html">PropertyTag</a>&gt;
-property_map&lt;filtered_graph, Tag&gt;::const_type
-get(PropertyTag, const filtered_graph&amp; g)
-</pre>
-Returns the property map object for the vertex property specified by
-<TT>PropertyTag</TT>. The <TT>PropertyTag</TT> must match one of the
-properties specified in the graph's <TT>VertexProperty</TT> template
-argument.
-
-<hr>
-
-<pre>
-template &lt;class <a href="./PropertyTag.html">PropertyTag</a>, class X&gt;
-typename property_traits&lt;property_map&lt;filtered_graph, PropertyTag&gt;::const_type&gt::value_type
-get(PropertyTag, const filtered_graph&amp; g, X x)
-</pre>
-This returns the property value for <tt>x</tt>, where <tt>x</tt> is either
-a vertex or edge descriptor.
-<hr>
-
-<pre>
-template &lt;class <a href="./PropertyTag.html">PropertyTag</a>, class X, class Value&gt;
-void
-put(PropertyTag, const filtered_graph&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;filtered_graph, PropertyTag&gt;::type&gt::value_type</tt>
-
-<hr>
-
-<h3>See Also</h3>
-
-<a href="./property_map.html"><tt>property_map</tt></a>,
-<a href="./graph_traits.html"><tt>graph_traits</tt></a>
-
-<h3>Notes</h3>
-
-<p>
-<a name="1">[1]</a> The reason for requiring <a
-href="http://www.sgi.com/tech/stl/DefaultConstructible.html">Default
-Constructible</a> in the <tt>EdgePredicate</tt> and
-<tt>VertexPredicate</tt> types is that these predicates are stored
-by-value (for performance reasons) in the filter iterator adaptor, and
-iterators are required to be Default Constructible by the C++
-Standard.
-
-<p>
-<a name="2">[2]</a> It would be nicer to return the number of
-vertices remaining after the filter has been applied, but
-this has two problems. The first is that it would take longer
-to calculate, and the second is that it would interact badly
-with the underlying vertex index mapping. The index mapping
-would no longer fall in the range <tt>[0,num_vertices(g))</tt>
-which is assumed in many of the algorithms. We are working
-on a solution that will remove that assumption from the
-algorithms.
-
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/graph_coloring.html

@@ -1,195 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Graph Coloring Example</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1>Graph Coloring</H1>
-
-The graph (or vertex) coloring problem, which involves assigning
-colors to vertices in a graph such that adjacenct vertices have
-distinct colors, arises in a number of scientific and engineering
-applications such as scheduling&nbsp;, register allocation&nbsp;,
-optimization&nbsp; and parallel numerical computation.
-
-<P>
-Mathmatically, a proper vertex coloring of an undirected graph
-<i>G=(V,E)</i> is a map <i>c: V -> S</i> such that <i>c(u) != c(v)</i>
-whenever there exists an edge <i>(u,v)</i> in <i>G</i>. The elements
-of set <i>S</i> are called the available colors. The problem is often
-to determine the minimum cardinality (the number of colors) of
-<i>S</i> for a given graph <i>G</i> or to ask whether it is able to
-color graph <i>G</i> with a certain number of colors. For example, how
-many color do we need to color the United States on a map in such a
-way that adjacent states have different color? A compiler needs to
-decide whether variables and temporaries could be allocated in fixed
-number of registers at some point.  If a target machine has <i>K</i>
-registers, can a particular interference graph be colored with
-<i>K</i> colors? (Each vertex in the interference graph represents a
-temporary value; each edge indicates a pair of temporaries that cannot
-be assigned to the same register.)
-
-<P>
-Another example is in the estimation of sparse Jacobian matrix by
-differences in large scale nonlinear problems in optimization and
-differential equations. Given a nonlinear function <i>F</i>, the
-estimation of Jacobian matrix <i>J</i> can be obtained by estimating
-<i>Jd</i> for suitable choices of vector <i>d</i>. Curtis, Powell and
-Reid&nbsp;[<a href="bibliography.html#curtis74:_jacob">9</a>] observed that a group of columns of <i>J</i> can be
-determined by one evaluation of <i>Jd</i> if no two columns in this
-group have a nonzero in the same row position.  Therefore, a question
-is emerged: what is the number of function evaluations need to compute
-approximate Jacobian matrix?  As a matter of fact this question is the
-same as to compute the minimum numbers of colors for coloring a graph
-if we construct the graph in the following matter: A vertex represents
-a column of <i>J</i> and there is an edge if and only if the two
-column have a nonzero in the same row position.
-
-<P>
-However, coloring a general graph with the minimum number of colors
-(the cardinality of set <i>S</i>) is known to be an NP-complete
-problem&nbsp;[<a
-href="bibliography.html#garey79:computers-and-intractability">30</a>].
-One often relies on heuristics to find a solution. A widely-used
-general greedy based approach is starting from an ordered vertex
-enumeration <i>v<sub>1</sub>, ..., v<sub>n</sub></i> of <i>G</i>, to
-assign <i>v<sub>i</sub></i> to the smallest possible color for
-<i>i</i> from <i>1</i> to <i>n</i>.  In section <a
-href="constructing_algorithms.html">Constructing graph
-algorithms with BGL</a> we have shown how to write this algorithm in
-the generic programming paradigm. However, the ordering of the
-vertices dramatically affects the coloring.  The arbitrary order may
-perform very poorly while another ordering may produces an optimal
-coloring.  Several ordering algorithms have been studied to help the
-greedy coloring heuristics including largest-first ordering,
-smallest-last ordering and incidence degree ordering.
-
-<P>
-In the BGL framework,  the process of constructing/prototyping such a
-ordering is fairly easy because  writing such a ordering  follows the
-algorithm  description   closely.  As  an  example,   we  present  the
-smallest-last ordering algorithm.
-
-<P>
-The basic idea of the smallest-last ordering&nbsp;[<a
-href="bibliography.html#matula72:_graph_theory_computing">29</a>] is
-as follows: Assuming that the vertices <i>v<sub>k+1</sub>, ...,
-v<sub>n</sub></i> have been selected, choose <i>v<sub>k</sub></i> so
-that the degree of <i>v<sub>k</sub></i> in the subgraph induced by
-<i>V - {v<sub>k+1</sub>, ..., v<sub>n</sub>}</i> is minimal.
-
-<P>
-The algorithm uses a bucket sorter for the vertices in the graph where
-bucket is the degree. Two vertex property maps, <TT>degree</TT> and
-<TT>marker</TT>,  are used  in the  algorithm.  The former  is to  store
-degree of  every vertex while the  latter is to mark  whether a vertex
-has been ordered or processed during traversing adjacent vertices. The
-ordering is stored in the <TT>order</TT>. The algorithm is as follows:
-
-<UL>
-<LI>put all vertices in the bucket sorter
-</LI>
-<LI>find the vertex <tt>node</tt> with smallest degree in the bucket sorter
-</LI>
-<LI>number <tt>node</tt> and traverse through its adjacent vertices to
- update its degree and the position in the bucket sorter.
-</LI>
-<LI>go to the step 2 until all vertices are numbered.
-</LI>
-</UL>
-
-<P>
-<PRE>
-namespace boost {
-  template &lt;class VertexListGraph, class Order, class Degree, 
-            class Marker, class BucketSorter&gt;
-  void 
-  smallest_last_ordering(const VertexListGraph&amp; G, Order order, 
-                         Degree degree, Marker marker, 
-                         BucketSorter&amp; bucket_sorter) {
-    typedef typename graph_traits&lt;VertexListGraph&gt; GraphTraits;
-
-    typedef typename GraphTraits::vertex_descriptor Vertex;
-    //typedef typename GraphTraits::size_type size_type;
-    typedef size_t size_type;
-
-    const size_type num = num_vertices(G);
-    
-    typename GraphTraits::vertex_iterator v, vend;
-    for (tie(v, vend) = vertices(G); v != vend; ++v) {
-      put(marker, *v, num);
-      put(degree, *v, out_degree(*v, G));
-      degree_buckets.push(*v);
-    }
- 
-    size_type minimum_degree = 1;
-    size_type current_order = num - 1;
-    
-    while ( 1 ) {
-      typedef typename BucketSorter::stack MDStack;
-      MDStack minimum_degree_stack = degree_buckets[minimum_degree];
-      while (minimum_degree_stack.empty())
-        minimum_degree_stack = degree_buckets[++minimum_degree];
-      
-      Vertex node = minimum_degree_stack.top();
-      put(order, current_order, node);
-      
-      if ( current_order == 0 ) //find all vertices
-        break;
-      
-      minimum_degree_stack.pop();
-      put(marker, node, 0); //node has been ordered.
-      
-      typename GraphTraits::adjacency_iterator v, vend;
-      for (tie(v,vend) = adjacent_vertices(node, G); v != vend; ++v)
-        
-        if ( get(marker, *v) &gt; current_order ) { //*v is unordered vertex
-          put(marker, *v, current_order);   //mark the columns adjacent to node
-          
-          //It is possible minimum degree goes down
-          //Here we keep tracking it.
-          put(degree, *v, get(degree, *v) - 1); 
-          minimum_degree = std::min(minimum_degree, get(degree, *v)); 
-          
-          //update the position of *v in the bucket sorter
-          degree_buckets.update(*v);
-        }
-
-      current_order--;
-    }
-    //at this point, get(order, i) == vertex(i, g);
-  }
-} // namespace boost
-</PRE>
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/graph_concepts.html

@@ -1,497 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Concepts</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-
-<H1><A NAME="chapter:graph-concepts"></A>
-Graph Concepts
-</H1>
-
-<P>
-The heart of the Boost Graph Library (BGL) is the interface, or
-concepts (in the parlance of generic programming), that define how a
-graph can be examined and manipulated in a data-structure neutral
-fashion. In fact, the BGL interface need not even be implemented using
-a data-structure, as for some problems it is easier or more efficient
-to define a graph implicitly based on some functions.
-
-<P>
-The BGL interface does not appear as a single graph concept.  Instead
-it is factored into much smaller peices. The reason for this is that
-the purpose of a concept is to summarize the requirements for
-<i>particular</i> algorithms. Any one algorithm does not need every
-kind of graph operation, typically only a small subset.  Furthermore,
-there are many graph data-structures that can not provide efficient
-implementations of all the operations, but provide highly efficient
-implementations of the operations necessary for a particular algorithm
-. By factoring the graph interface into many smaller concepts we
-provide the graph algorithm writer with a good selection from which to
-choose the concept that is the closest match for their algorithm.
-
-<H2>Graph Structure Concepts Overview</H2>
-
-<P>
-<A HREF="#fig:graph-concepts">Figure 1</A> shows the refinements
-relations between the graph concepts. The reason for factoring the
-graph interface into so many concepts is to encourage algorithm
-interfaces to require and use only the minimum interface of a graph,
-thereby increasing the reusability of the algorithm.
-
-
-<p></p>
-<DIV ALIGN="CENTER"><A NAME="fig:graph-concepts"></A></A>
-<TABLE>
-<CAPTION ALIGN="BOTTOM"><STRONG>Figure 1:</STRONG>
-The graph concepts and refinement relationships.
-</CAPTION>
-<TR><TD><IMG SRC="./figs/concepts.gif" width="519" height="139"></TD></TR>
-</TABLE>
-</DIV>
-<p></p>
-
-<A HREF="#tab:graph-concept-reqs">Table&nbsp;1</A>
-gives a summary of the valid expressions and associated types for the
-graph concepts and provides links to the detailed descriptions of
-each of the concepts. The notation used in the table is as follows.
-
-<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>e_iter</tt></TD>
-<TD>An object of type <tt>boost::graph_traits&lt;G&gt;::out_edge_iterator</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>ep</TT></TD><TD>is an object of type <TT>G::edge_property_type</TT></TD>
-</TR>
-
-<TR>
-<TD><TT>vp</TT></TD><TD>is an object of type <TT>G::vertex_property_type</TT></TD>
-</TR>
-
-<TR>
-<TD><tt>Property</tt></TD>
-<TD>A type used to specify a vertex or edge property.</TD>
-</TR>
-
-<TR>
-<TD><tt>property</tt></TD>
-<TD>An object of type <tt>Property</tt>.</td>
-</TR>
-
-</table>
-
-
-
-
-<P>
-<BR><P></P>
-<DIV ALIGN="CENTER"><A NAME="tab:graph-concept-reqs"></A>
-<TABLE>
-<CAPTION ALIGN="BOTTOM"><STRONG>Table 1:</STRONG>
-    Summary of the graph concepts.
-    </CAPTION>
-<TR><TD>  
-<TABLE border>
-<TR><TH ALIGN="LEFT">
-<B>Expression</B> </TH>
-<TH ALIGN="LEFT" VALIGN="TOP"> <B>Return Type or Description</B> </TH>
-</TR>
-<TR><TD ALIGN="LEFT" COLSPAN=2>  
- <a href="./Graph.html">Graph</a> </TD>
-</TR>
-<TR><TD ALIGN="LEFT">  
-<TT>boost::graph_traits&lt;G&gt;::vertex_descriptor</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP">  The type for
-  vertex representative objects. </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>boost::graph_traits&lt;G&gt;::edge_descriptor</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> The type for
-  edge representative objects. </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>boost::graph_traits&lt;G&gt;::directed_category</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> Directed or undirected? </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>boost::graph_traits&lt;G&gt;::edge_parallel_category</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> Allow parallel edges? </TD>
-</TR>
-<TR><TD ALIGN="LEFT">
-<TT>boost::graph_traits&lt;G&gt;::traversal_category</TT> </TD> <TD
-ALIGN="LEFT" VALIGN="TOP">The ways in which the vertices and edges of
-the graph can be visited.</TD>
-</TR>
-<!---------------------------------------------------------------->
-<TR><TD ALIGN="LEFT" COLSPAN=2>  
- <a href="./IncidenceGraph.html">IncidenceGraph</a> refines Graph </TD>
-</TR>
-<TR><TD ALIGN="LEFT">  
-<TT>boost::graph_traits&lt;G&gt;::out_edge_iterator</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> Iterate through
-  the out-edges. </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>boost::graph_traits&lt;G&gt;::degree_size_type</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> The integer type for
-vertex degee. </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>out_edges(v, g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>std::pair&lt;out_edge_iterator, out_edge_iterator&gt;</TT> </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>source(e, g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>vertex_descriptor</TT> </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>target(e, g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>vertex_descriptor</TT> </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>out_degree(v, g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>degree_size_type</TT> </TD>
-</TR>
-<!---------------------------------------------------------------->
-<TR><TD ALIGN="LEFT" COLSPAN=2>  
- <a href="./BidirectionalGraph.html">BidirectionalGraph</a> refines
-  IncidenceGraph </TD>
-</TR>
-<TR><TD ALIGN="LEFT">  
-<TT>boost::graph_traits&lt;G&gt;::in_edge_iterator</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> Iterate through the in-edges. </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>in_edges(v, g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>std::pair&lt;in_edge_iterator, in_edge_iterator&gt;</TT> </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>in_degree(v, g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>degree_size_type</TT> </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>degree(e, g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>degree_size_type</TT> </TD>
-</TR>
-<!---------------------------------------------------------------->
-<TR><TD ALIGN="LEFT" COLSPAN=2>  
-<a href="./AdjacencyGraph.html">AdjacencyGraph</a> refines Graph</TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>boost::graph_traits&lt;G&gt;::adjacency_iterator</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> Iterate through
-  adjacent vertices. </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>adjacent_vertices(v, g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"><TT>std::pair&lt;adjacency_iterator, adjacency_iterator&gt;</TT> </TD>
-</TR>
-<!---------------------------------------------------------------->
-<TR><TD ALIGN="LEFT" COLSPAN=2>  
-<a href="./VertexListGraph.html">VertexListGraph</a> refines
-  IncidenceGraph and AdjacencyGraph </TD>
-</TR>
-<TR><TD ALIGN="LEFT">  
-<TT>boost::graph_traits&lt;G&gt;::vertex_iterator</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> Iterate through the
-  graph's vertex set. </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>boost::graph_traits&lt;G&gt;::vertices_size_type</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> The unsigned integer type for
-number of vertices in the graph. </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>vertices(g)</TT>  </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"><TT>std::pair&lt;vertex_iterator, vertex_iterator&gt;</TT> </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>num_vertices(g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>vertices_size_type</TT>  </TD>
-</TR>
-<!---------------------------------------------------------------->
-<TR><TD ALIGN="LEFT" COLSPAN=2>  
-<a href="./EdgeListGraph.html">EdgeListGraph</a> refines Graph</TD>
-</TR>
-<TR><TD ALIGN="LEFT">  
-<TT>boost::graph_traits&lt;G&gt;::edge_iterator</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> Iterate through the graph's
-  edge set. </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>boost::graph_traits&lt;G&gt;::edges_size_type</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> The unsigned integer type for
-number of edges in the graph. </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>edges(g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>std::pair&lt;edge_iterator, edge_iterator&gt;</TT> </TD>
-</TR>
-<TR><TD ALIGN="LEFT">  
-<TT>num_edges(g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>edges_size_type</TT>  </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>source(e, g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>vertex_descriptor</TT> </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>target(e, g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>vertex_descriptor</TT> </TD>
-</TR>
-<!---------------------------------------------------------------->
-<TR><TD ALIGN="LEFT" COLSPAN=2>  
-<a href="./AdjacencyMatrix.html">AdjacencyMatrix</a> refines Graph</TD>
-</TR>
-<TR><TD ALIGN="LEFT">  
-<TT>edge(u, v, g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>std::pair&lt;edge_descriptor, bool&gt;</TT> </TD>
-</TR>
-<TR><TD ALIGN="LEFT" COLSPAN=2>  
-<a href="./MutableGraph.html">MutableGraph</a> refines
-  Graph</TD>
-</TR>
-<TR><TD ALIGN="LEFT">  
-<TT>add_vertex(g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>vertex_descriptor</TT> </TD>
-</TR>
-<TR><TD ALIGN="LEFT">  
-<TT>clear_vertex(v, g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>void</TT> </TD>
-</TR>
-<TR><TD ALIGN="LEFT">  
-<TT>remove_vertex(v, g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>void</TT> </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>add_edge(u, v, g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>std::pair&lt;edge_descriptor, bool&gt;</TT> </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>remove_edge(u, v, g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>void</TT> </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>remove_edge(e, g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>void</TT> </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>remove_edge(e_iter, g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>void</TT> </TD>
-</TR>
-<!---------------------------------------------------------------->
-<TR><TD ALIGN="LEFT" COLSPAN=2>  
-<a href="./MutablePropertyGraph.html">MutablePropertyGraph</a> refines
-  Graph</TD>
-</TR>
-<TR><TD ALIGN="LEFT">  
-<TT>add_vertex(vp, g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>vertex_descriptor</TT> </TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>add_edge(u, v, ep, g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> <TT>std::pair&lt;edge_descriptor,
-  bool&gt;</TT> </TD>
-</TR>
-<!---------------------------------------------------------------->
-<TR>
-<TD ALIGN="LEFT" COLSPAN=2>  
-<a href="./PropertyGraph.html">PropertyGraph</a> refines Graph</TD>
-</TR>
-<TR><TD ALIGN="LEFT">  
-<TT>boost::property_map&lt;G, Property&gt;::type</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP">Type for a mutable property map.</TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>boost::property_map&lt;G, Property&gt;::const_type</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP">Type for a non-mutable property map.</TD>
-</TR>
-<TR><TD ALIGN="LEFT"> 
-<TT>get(property, g)</TT> </TD>
-<TD ALIGN="LEFT" VALIGN="TOP"> Function to get a property map. </TD>
-</TR>
-
-<TR><TD ALIGN="LEFT"> 
-<TT>get(property,&nbsp;g,&nbsp;x)</TT>
-</TD>
-<TD ALIGN="LEFT" VALIGN="TOP">Get property value for vertex or edge <tt>x</tt>. </TD>
-</TR>
-
-<TR><TD ALIGN="LEFT"> 
-<TT>put(property,&nbsp;g,&nbsp;x,&nbsp;v)</TT>
-</TD>
-<TD ALIGN="LEFT" VALIGN="TOP">Set property value for vertex or edge
-<tt>x</tt> to <tt>v</tt>. </TD>
-</TR>
-
-</table>
-</table>
-</DIV><P></P>
-<BR>
-
-<P>
-
-<H2><A NAME="sec:undirected-graphs"></A>
-Undirected Graphs
-</H2>
-
-<P>
-The interface that the BGL provides for accessing and manipulating an
-undirected graph is the same as the interface for directed graphs
-described in the following sections, however there are some
-differences in the behaviour and semantics.  For example, in a
-directed graph we can talk about out-edges and in-edges of a vertex.
-In an undirected graph there is no ``in'' and ``out'', there are just
-edges incident to a vertex. Nevertheless, in the BGL we still use the
-<TT>out_edges()</TT> function (or <TT>in_edges()</TT>) to access the
-incident edges in an undirected graph. Similarly, an undirected edge
-has no ``source'' and ``target'' but merely an unordered pair of
-vertices, but in the BGL we still use <TT>source()</TT> and
-<TT>target()</TT> to access these vertices.  The reason the BGL does
-not provide a separate interface for undirected graphs is that many
-algorithms on directed graphs also work on undirected graphs, and it
-would be inconvenient to have to duplicate the algorithms just because
-of an interface difference. When using undirected graphs just mentally
-disregard the directionality in the function names. The example below
-demonstrates using the <TT>out_edges()</TT>, <TT>source()</TT>, and
-<TT>target()</TT> with an undirected graph. The source code for this
-example and the following one can be found in <a
-href="../example/undirected.cpp"><TT>examples/undirected.cpp</TT></a>.
-
-<P>
-<PRE>
-  const int V = 2;
-  typedef ... UndirectedGraph;
-  UndirectedGraph undigraph(V);
-
-  std::cout &lt;&lt; "the edges incident to v: ";
-  boost::graph_traits&lt;UndirectedGraph&gt;::out_edge_iterator e, e_end;
-  boost::graph_traits&lt;UndirectedGraph&gt;::vertex_descriptor 
-    s = vertex(0, undigraph);
-  for (tie(e, e_end) = out_edges(s, undigraph); e != e_end; ++e)
-    std::cout &lt;&lt; "(" &lt;&lt; source(*e, undigraph) 
-              &lt;&lt; "," &lt;&lt; target(*e, undigraph) &lt;&lt; ")" &lt;&lt; endl;
-</PRE>
-
-<P>
-Even though the interface is the same for undirected graphs, there are
-some behavioral differences because edge equality is defined
-differently. In a directed graph, edge <i>(u,v)</i> is never equal to edge
-<i>(v,u)</i>, but in an undirected graph they may be equal.  If the
-undirected graph is a multigraph then <i>(u,v)</i> and <i>(v,u)</i> might be
-parallel edges. If the graph is not a multigraph then <i>(u,v)</i> and
-<i>(v,u)</i> must be the same edge.
-
-<P>
-In the example below the edge equality test will return <TT>false</TT>
-for the directed graph and <TT>true</TT> for the undirected graph. The
-difference also affects the meaning of <TT>add_edge()</TT>. In the
-example below, if we had also written <TT>add_add(v, u,
-undigraph)</TT>, this would have added a parallel edge between
-<i>u</i> and <i>v</i> (provided the graph type allows parallel
-edges). The difference in edge equality also affects the association
-of edge properties. In the directed graph, the edges <i>(u,v)</i> and
-<i>(v,u)</i> can have distinct weight values, whereas in the
-undirected graph the weight of <i>(u,v)</i> is the same as the weight
-of <i>(v,u)</i> since they are the same edge.
-
-<P>
-<PRE>
-  typedef ... DirectedGraph;
-  DirectedGraph digraph(V);
-  {
-    boost::graph_traits&lt;DirectedGraph&gt;::vertex_descriptor u, v;
-    u = vertex(0, digraph);
-    v = vertex(1, digraph);
-    add_edge(digraph, u, v, Weight(1.2));
-    add_edge(digraph, v, u, Weight(2.4));
-    boost::graph_traits&lt;DirectedGraph&gt;::edge_descriptor e1, e2;
-    bool found;
-    tie(e1, found) = edge(u, v, digraph);
-    tie(e2, found) = edge(v, u, digraph);
-    std::cout &lt;&lt; "in a directed graph is ";
-    std::cout &lt;&lt; "(u,v) == (v,u) ? " &lt;&lt; (e1 == e2) &lt;&lt; std::endl;
-
-    property_map&lt;DirectedGraph, edge_weight_t&gt;::type
-      weight = get(edge_weight, digraph);
-    cout &lt;&lt; "weight[(u,v)] = " &lt;&lt; get(weight, e1) &lt;&lt; endl;
-    cout &lt;&lt; "weight[(v,u)] = " &lt;&lt; get(weight, e2) &lt;&lt; endl;
-  }
-  {
-    boost::graph_traits&lt;UndirectedGraph&gt;::vertex_descriptor u, v;
-    u = vertex(0, undigraph);
-    v = vertex(1, undigraph);
-    add_edge(undigraph, u, v, Weight(3.1));
-    boost::graph_traits&lt;UndirectedGraph&gt;::edge_descriptor e1, e2;
-    bool found;
-    tie(e1, found) = edge(u, v, undigraph);
-    tie(e2, found) = edge(v, u, undigraph);
-    std::cout &lt;&lt; "in an undirected graph is ";
-    std::cout &lt;&lt; "(u,v) == (v,u) ? " &lt;&lt; (e1 == e2) &lt;&lt; std::endl;
-
-    property_map&lt;UndirectedGraph, edge_weight_t&gt;::type
-      weight = get(edge_weight, undigraph);
-    cout &lt;&lt; "weight[(u,v)] = " &lt;&lt; get(weight, e1) &lt;&lt; endl;
-    cout &lt;&lt; "weight[(v,u)] = " &lt;&lt; get(weight, e2) &lt;&lt; endl;
-  }
-</PRE>
-The output is:
-<PRE>
-in a directed graph is (u,v) == (v,u) ? 0
-weight[(u,v)] = 1.2
-weight[(v,u)] = 2.4
-in an undirected graph is (u,v) == (v,u) ? 1
-weight[(u,v)] = 3.1
-weight[(v,u)] = 3.1
-</PRE>
-
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../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/graph_theory_review.html

@@ -1,594 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: Graph Theory Review</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1>Review of Elementary Graph Theory</H1>
-
-<P>
-
-<P>
-This chapter is meant as a refresher on elementary graph theory. If
-the reader has some previous acquaintance with graph algorithms, this
-chapter should be enough to get started.  If the reader has no
-previous background in graph algorithms we suggest a more thorough
-introduction such as <a
-href="http://www.toc.lcs.mit.edu/~clr/">Introduction to Algorithms</a>
-by Cormen, Leiserson, and Rivest.
-
-<P>
-
-<H1>The Graph Abstraction</H1>
-
-<P>
-A graph is a mathematical abstraction that is useful for solving many
-kinds of problems. Fundamentally, a graph consists of a set of
-vertices, and a set of edges, where an edge is something that connects
-two vertices in the graph. More precisely, a <a
-name="def:graph"><I>graph</I></a> is a pair <i>(V,E)</i>, where
-<i>V</i> is a finite set and <i>E</i> is a binary relation on
-<i>V</i>. <i>V</i> is called a <a name="def:vertex-set"><I>vertex
-set</I></a> whose elements are called <I>vertices</I>.  <i>E</i> is a
-collection of edges, where an <a name="def:edge"><I>edge</I></a> is a
-pair <i>(u,v)</i> with <i>u,v</i> in <i>V</i>.  In a <a
-name="def:directed-graph"><I>directed graph</I></a>, edges are ordered
-pairs, connecting a <a name="def:source"><I>source</I></a> vertex to a
-<a name="def:target"><I>target</I></a> vertex. In an <a
-name="def:undirected-graph"><I>undirected graph</I></a> edges are
-unordered pairs and connect the two vertices in both directions, hence
-in an undirected graph <i>(u,v)</i> and <i>(v,u)</i> are two ways of
-writing the same edge.
-
-<P>
-This definition of a graph is vague in certain respects; it does not
-say what a vertex or edge represents. They could be cities with
-connecting roads, or web-pages with hyperlinks. These details are left
-out of the definition of a graph for an important reason; they are not
-a necessary part of the graph <I>abstraction</I>. By leaving out the
-details we can construct a theory that is reusable, that can help us
-solve lots of different kinds of problems.
-
-<P>
-Back to the definition: a graph is a set of vertices and edges.  For
-purposes of demonstration, let us consider a graph where we have
-labeled the vertices with letters, and we write an edge simply as a
-pair of letters. Now we can write down an example of a directed graph
-as follows:
-
-<P>
-<BR>
-<DIV ALIGN="center">
-<table><tr><td><tt>
-V = {v, b, x, z, a, y } <br>
-E = { (b,y), (b,y), (y,v), (z,a), (x,x), (b,x), (x,v), (a,z) } <br>
-G = (V, E)
-</tt></td></tr></table>
-</DIV>
-<BR CLEAR="ALL"><P></P>
-
-
-<P>
-<A HREF="#fig:directed-graph">Figure 1</A> gives a pictorial view of
-this graph.  The edge <i>(x,x)</i> is called a <a
-name="def:self-loop"><I>self-loop</I></a>.  Edges <i>(b,y)</i> and
-<i>(b,y)</i> are <I>parallel edges</I>, which are allowed in a <a
-name="def:multigraph"><I>multigraph</I></a> (but are normally not
-allowed in a directed or undirected graph).
-
-<P>
-
-<P></P>
-<DIV ALIGN="center"><A NAME="fig:directed-graph"></A><A NAME="1509"></A>
-<TABLE>
-<CAPTION ALIGN="BOTTOM"><STRONG>Figure 1:</STRONG>
-Example of a directed graph.</CAPTION>
-<TR><TD><IMG SRC="./figs/digraph.gif" width="124" height="163"></TD></TR>
-</TABLE>
-</DIV><P></P>
-
-<P>
-Next we have a similar graph, though this time it is undirected.  <A
-HREF="#fig:undirected-graph">Figure 2</A> gives the pictorial view.
-Self loops are not allowed in undirected graphs. This graph is the <a
-name="def:undirected-version"><I>undirected version</i></a. of the the
-previous graph (minus the parallel edge <i>(b,y)</i>), meaning it has
-the same vertices and the same edges with their directions removed.
-Also the self edge has been removed, and edges such as <i>(a,z)</i>
-and <i>(z,a)</i> are collapsed into one edge. One can go the other
-way, and make a <a name="def:directed-version"><I>directed version</i>
-of an undirected graph be replacing each edge by two edges, one
-pointing in each direction.
-
-<P>
-<BR>
-<DIV ALIGN="CENTER">
-<table><tr><td><tt>
-V = {v, b, x, z, a, y }<br>
-E = { (b,y), (y,v), (z,a), (b,x), (x,v) }<br>
-G = (V, E)
-</tt></td></tr></table>
-</DIV>
-<BR CLEAR="ALL"><P></P>
-
-<P>
-
-<P></P>
-<DIV ALIGN="CENTER"><A NAME="fig:undirected-graph"></A><A NAME="1524"></A>
-<TABLE>
-<CAPTION ALIGN="BOTTOM"><STRONG>Figure 2:</STRONG>
-Example of an undirected graph.</CAPTION>
-<TR><TD><IMG SRC="./figs/undigraph.gif" width="103" height="163"></TD></TR>
-</TABLE>
-</DIV><P></P>
-
-<P>
-Now for some more graph terminology. If some edge <i>(u,v)</i> is in
-graph , then vertex <i>v</i> is <a
-name="def:adjacent"><I>adjacent</I></a> to vertex <i>u</i>.  In a
-directed graph, edge <i>(u,v)</i> is an <a
-name="def:out-edge"><I>out-edge</I></a> of vertex <i>u</i> and an <a
-name="def:in-edge"><I>in-edge</I></a> of vertex <i>v</i>. In an
-undirected graph edge <i>(u,v)</i> is <a
-name="def:incident-on"><I>incident on</I></a> vertices <i>u</i> and
-<i>v</i>.
-
-<P>
-In <A HREF="#fig:directed-graph">Figure 1</A>,
- vertex <i>y</i> is adjacent to vertex <i>b</i> (but <i>b</i> is not
- adjacent to <i>y</i>). The edge <i>(b,y)</i> is an out-edge of
- <i>b</i> and an in-edge of <i>y</i>. In <A
- HREF="#fig:undirected-graph">Figure 2</A>,
- <i>y</i> is adjacent to <i>b</i> and vice-versa. The edge
- <i>(y,b)</i> is incident on vertices <i>y</i> and <i>b</i>.
-
-<P>
-In a directed graph, the number of out-edges of a vertex is its <a
-name="def:out-degree"><I>out-degree</I></a> and the number of in-edges
-is its <a name="def:in-degree"><I>in-degree</I></a>.  For an
-undirected graph, the number of edges incident to a vertex is its <a
-name="def:degree"><I>degree</I></a>. In <A
-HREF="#fig:directed-graph">Figure 1</A>, vertex <i>b</i> has an
-out-degree of 3 and an in-degree of zero. In <A
-HREF="#fig:undirected-graph">Figure 2</A>, vertex <i>b</i> simply has
-a degree of 2.
-
-<P>
-Now a <a name="def:path"><i>path</i></a> is a sequence of edges in a
-graph such that the target vertex of each edge is the source vertex of
-the next edge in the sequence. If there is a path starting at vertex
-<i>u</i> and ending at vertex <i>v</i> we say that <i>v</i> is <a
-name="def:reachable"><i>reachable</i></a> from <i>u</i>.  A path is <a
-name="def:simple-path"><I>simple</I></a> if none of the vertices in
-the sequence are repeated. The path &lt;(b,x), (x,v)&gt; is simple,
-while the path &lt;(a,z), (z,a)&gt; is not. Also, the path &lt;(a,z),
-(z,a)&gt; is called a <a name="def:cycle"><I>cycle</I></a> because the
-first and last vertex in the path are the same. A graph with no cycles
-is <a name="def:acyclic"><I>acyclic</I></a>.
-
-<P>
-A <a name="def:planar-graph"><I>planar graph</I></a> is a graph that
-can be drawn on a plane without any of the edges crossing over each
-other. Such a drawing is called a <I>plane graph</I>. A <a
-name="def:face"><I>face</I></a> of a plane graph is a connected region
-of the plane surrounded by edges. An important property of planar
-graphs is that the number of faces, edges, and vertices are related
-through Euler's formula: <i>|F| - |E| + |V| = 2</i>. This means that a
-simple planar graph has at most <i>O(|V|)</i> edges.
-
-<P>
-
-<P>
-
-<H1>Graph Data Structures</H1>
-
-<P>
-The primary property of a graph to consider when deciding which data
-structure to use is <I>sparsity</I>, the number of edges relative to
-the number of vertices in the graph. A graph where <i>E</i> is close
-to </i>V<sup>2</sup></i> is a <I>dense</I> graph, whereas a graph
-where <i>E = alpha V</i> and <i>alpha</i> is much smaller than
-<i>V</i> is a <I>sparse</I> graph. For dense graphs, the
-<I>adjacency-matrix representation</I> is usually the best choice,
-whereas for sparse graphs the <I>adjacency-list representation</I> is
-a better choice. Also the <I>edge-list representation</I> is a space
-efficient choice for sparse graphs that is appropriate in some
-situations.
-
-<P>
-
-<H2>Adjacency Matrix Representation</H2>
-
-<P>
-An adjacency-matrix representation of a graph is a 2-dimensional <i>V
-x V</i> array. Each element in the array <i>a<sub>uv</sub></i> stores
-a Boolean value saying whether the edge <i>(u,v)</i> is in the graph.
-<A HREF="#fig:adj-matrix">Figure 3</A> depicts an adjacency matrix for
-the graph in <A HREF="#fig:directed-graph">Figure 1</A> (minus the
-parallel edge <i>(b,y)</i>).  The ammount of space required to store
-an adjacency-matrix is <i>O(V<sup>2</sup>)</i>. Any edge can be
-accessed, added, or removed in <i>O(1)</i> time.  To add or remove a
-vertex requires reallocating and copying the whole graph, an
-<i>O(V<sup>2</sup>)</i> operation.  The <a
-href="./adjacency_matrix.html"><tt>adjacency_matrix</tt></a> class
-implements the BGL graph interface in terms of the adjacency-matrix
-data-structure.
-
-
-<P>
-
-<P></P>
-<DIV ALIGN="CENTER"><A NAME="fig:adj-matrix"></A><A NAME="1701"></A>
-<TABLE>
-<CAPTION ALIGN="BOTTOM"><STRONG>Figure 3:</STRONG>
-The Adjacency Matrix Graph Representation.</CAPTION>
-<TR><TD><IMG SRC="./figs/adj_matrix.gif" width="136" height="135"></TD></TR>
-</TABLE>
-</DIV><P></P>
-
-<P>
-
-<H2><A NAME="sec:adjacency-list-representation"></A>
-Adjacency List Representation
-</H2>
-
-<P>
-An adjacency-list representation of a graph stores an out-edge
-sequence for each vertex. For sparse graphs this saves space since
-only <i>O(V + E)</i> memory is required. In addition, the out-edges
-for each vertex can be accessed more efficiently. Edge insertion is
-<i>O(1)</i>, though accessing any given edge is <i>O(alpha)</i>, where
-<i>alpha</i> is the sparsity factor of the matrix (which is equal to
-the maximum number of out-edges for any vertex in the graph).  <A
-HREF="#fig:adj-list">Figure 4</A> depicts an
-adjacency-list representation of the graph in <A
-HREF="#fig:directed-graph">Figure 1</A>. The
-<a href="./adjacency_list.html"><TT>adjacency_list</TT></a> class is
-an implementation of the adjacency-list representation.
-
-<P>
-
-<P></P>
-<DIV ALIGN="CENTER"><A NAME="fig:adj-list"></A><A NAME="1713"></A>
-<TABLE>
-<CAPTION ALIGN="BOTTOM"><STRONG>Figure 4:</STRONG>
-The Adjacency List Graph Representation.</CAPTION>
-<TR><TD><IMG SRC="./figs/adj_list.gif" width="108" height="122"></TD></TR>
-</TABLE>
-</DIV><P></P>
-
-<P>
-
-<H2>Edge List Representation</H2>
-
-<P>
-An edge-list representation of a graph is simply a sequence of edges,
-where each edge is represented as a pair of vertex ID's.  The memory
-required is only <i>O(E)</i>. Edge insertion is typically <i>O(1)</i>,
-though accessing a particular edge is <i>O(E)</i> (not efficient).  <A
-HREF="#fig:edge-list">Figure 5</A> shows an
-edge-list representation of the graph in <A
-HREF="#fig:directed-graph">Figure 1</A>. The
-<a href="./edge_list.html"><TT>edge_list</TT></a> adaptor class can be
-used to create implementations of the edge-list representation.
-
-<P>
-
-<P></P>
-<DIV ALIGN="CENTER"><A NAME="fig:edge-list"></A><A NAME="1724"></A>
-<TABLE>
-<CAPTION ALIGN="BOTTOM"><STRONG>Figure 5:</STRONG>
-The Edge List Graph Representation.</CAPTION>
-<TR><TD><IMG SRC="./figs/edge_list.gif" width="322" height="22"></TD></TR>
-</TABLE>
-</DIV><P></P>
-
-
-<P>
-
-<H1>Graph Algorithms</H1>
-
-<P>
-
-<H2>Graph Search Algorithms</H2>
-
-<P>
-<I>Tree edges</I> are edges in the search tree (or forest) constructed
-(implicitly or explicitly) by running a graph search algorithm over a
-graph.  An edge <i>(u,v)</i> is a tree edge if <i>v</i> was first
-discovered while exploring (corresponding to the <a
-href="./visitor_concepts.html">visitor</a> <TT>explore()</TT> method)
-edge <i>(u,v)</i>. <I>Back edges</I> connect vertices to their
-ancestors in a search tree. So for edge <i>(u,v)</i> the vertex
-<i>v</i> must be the ancestor of vertex <i>u</i>. Self loops are
-considered to be back edges. <I>Forward edges</I> are non-tree edges
-<i>(u,v)</i> that connect a vertex <i>u</i> to a descendant <i>v</i>
-in a search tree.  <I>Cross edges</I> are edges that do not fall into
-the above three categories.
-
-<P>
-
-<H2><A NAME="sec:bfs-algorithm"></A>
-Breadth-First Search
-</H2>
-
-<P>
-Breadth-first search is a traversal through a graph that touches all
-of the vertices reachable from a particular source vertex. In
-addition, the order of the traversal is such that the algorithm will
-explore all of the neighbors of a vertex before proceeding on to the
-neighbors of its neighbors. One way to think of breadth-first search
-is that it expands like a wave emanating from a stone dropped into a
-pool of water.  Vertices in the same ``wave'' are the same distance
-from the source vertex. A vertex is <I>discovered</I> the first time
-it is encountered by the algorithm. A vertex is <I>finished</I> after
-all of its neighbors are explored. Here's an example to help make this
-clear. A graph is shown in <A
-HREF="#fig:bfs-example">Figure 6</A> and the
-BFS discovery and finish order for the vertices is shown below.
-
-<P>
-
-<P></P>
-<DIV ALIGN="CENTER"><A NAME="fig:bfs-example"></A><A NAME="1826"></A>
-<TABLE>
-<CAPTION ALIGN="BOTTOM"><STRONG>Figure 6:</STRONG>
-Breadth-first search spreading through a graph.</CAPTION>
-<TR><TD><IMG SRC="./figs/bfs_example.gif" width="242" height="143"></TD></TR>
-</TABLE>
-</DIV><P></P>
-
-<P>
-<PRE>
-  order of discovery: s r w v t x u y 
-  order of finish: s r w v t x u y
-</PRE>
-
-<P>
-We start at vertex , and first visit <i>r</i> and <i>w</i> (the two
-neighbors of ). Once both neighbors of are visited, we visit the
-neighbor of <i>r</i> (vertex <i>v</i>), then the neighbors of <i>w</i>
-(the discovery order between <i>r</i> and <i>w</i> does not matter)
-which are <i>t</i> and <i>x</i>. Finally we visit the neighbors of
-<i>t</i> and <i>x</i>, which are <i>u</i> and <i>y</i>.
-
-<P>
-For the algorithm to keep track of where it is in the graph, and which
-vertex to visit next, BFS needs to color the vertices (see the section
-on <a href="./using_property_maps.html">Property Maps</a>
-for more details about attaching properties to graphs). The place to
-put the color can either be inside the graph, or it can be passed into
-the algorithm as an argument.
-
-<P>
-
-<H2><A NAME="sec:dfs-algorithm"></A>
-Depth-First Search
-</H2>
-
-<P>
-A depth first search (DFS) visits all the vertices in a graph. When
-choosing which edge to explore next, this algorithm always chooses to
-go ``deeper'' into the graph. That is, it will pick the next adjacent
-unvisited vertex until reaching a vertex that has no unvisited
-adjacent vertices. The algorithm will then backtrack to the previous
-vertex and continue along any as-yet unexplored edges from that
-vertex. After DFS has visited all the reachable vertices from a
-particular source vertex, it chooses one of the remaining undiscovered
-vertices and continues the search. This process creates a set of
-<I>depth-first trees</I> which together form the <I>depth-first
- forest</I>. A depth-first search categorizes the edges in the graph
-into three categories: tree-edges, back-edges, and forward or
-cross-edges (it does not specify which).  There are typically many
-valid depth-first forests for a given graph, and therefore many
-different (and equally valid) ways to categorize the edges.
-
-<P>
-One interesting property of depth-first search is that the discover
-and finish times for each vertex form a parenthesis structure.  If we
-use an open-parenthesis when a vertex is discovered, and a
-close-parenthesis when a vertex is finished, then the result is a
-properly nested set of parenthesis.  <A
-HREF="#fig:dfs-example">Figure 7</A> shows
-DFS applied to an undirected graph, with the edges labeled in the
-order they were explored.  Below we list the vertices of the graph
-ordered by discover and finish time, as well as show the parenthesis structure.  DFS is used as the kernel for several other graph
-algorithms, including topological sort and two of the connected
-component algorithms. It can also be used to detect cycles (see the <A
-HREF="file_dependency_example.html#sec:cycles">Cylic Dependencies </a>
-section of the File Dependency Example).
-
-<P>
-
-<P></P>
-<DIV ALIGN="CENTER"><A NAME="fig:dfs-example"></A><A NAME="1841"></A>
-<TABLE>
-<CAPTION ALIGN="BOTTOM"><STRONG>Figure 7:</STRONG>
-Depth-first search on an undirected graph.</CAPTION>
-<TR><TD><IMG SRC="./figs/dfs.gif" width="141" height="204"></TD></TR>
-</TABLE>
-</DIV><P></P>
-
-<P>
-<PRE>
-  order of discovery: a b e d c f g h i
-  order of finish: d f c e b a
-  parenthesis: (a (b (e (d d) (c (f f) c) e) b) a) (g (h (i i) h) g)
-</PRE>
-
-<P>
-
-<H2><a name="sec:minimum-spanning-tree">Minimum Spanning Tree Problem</a></H2>
-
-<P>
-The <I>minimum-spanning-tree problem</I> is defined as follows: find
-an acyclic subset <i>T</i> of <i>E</i> that connects all of the vertices
-in the graph and whose total weight is minimized, where the
-total weight is given by
-<P></P>
-<DIV ALIGN="left">
-<i>w(T)</i> = sum of <i>w(u,v)</i> over all <i>(u,v)</i> in <i>T</i>,
-where <i>w(u,v)</i> is the weight on the edge <i>(u,v)</i>
-</DIV>
-<BR CLEAR="ALL">
-<P></P>
-<i>T</i> is called the <I>spanning tree</I>.
-
-<!--
-<P>
-Kruskal's algorithm&nbsp;[<A
- HREF="bibliography.html#kruskal56">18</A>]
-for solving the minimum spanning tree problem. This is a greedy
-algorithm to calculate the minimum spanning tree for an undirected
-graph with weighted edges. 
-
-<P>
-This is Prim's algorithm&nbsp;[<A
- HREF="bibliography.html#prim57:_short">25</A>] for solving the
- minimum spanning tree problem for an undirected graph with weighted
- edges. The implementation is simply a call to <a
- href="./dijkstra_shortest_paths.html"><TT>dijkstra_shortest_paths()</TT></a>
- with the appropriate choice of comparison and combine functors.
--->
-
-<P>
-
-<H2><a name="sec:shortest-paths-algorithms">Shortest-Paths Algorithms</a></H2>
-
-<P>
-One of the classic problems in graph theory is to find the shortest
-path between two vertices in a graph. Formally, a <I>path</I> is a
-sequence of vertices <i>&lt;v<sub>0</sub>,v<sub>1</sub>,...,v<sub>k</sub>&gt;</i>
-in a graph <i>G = (V, E)</i> such that each vertex is connected to the
-next vertex in the sequence (the edges
-<i>(v<sub>i</sub>,v<sub>i+1</sub>)</i> for <i>i=0,1,...,k-1</i> are in
-the edge set <i>E</i>). In the shortest-path problem, each edge is
-given a real-valued weight. We can therefore talk about the <I>weight
-of a path</I><BR>
-
-<p></p>
-<DIV ALIGN="left">
-<i>w(p) = sum from i=1..k of w(v<sub>i-1</sub>,v<sub>i</sub>)</i>
-</DIV>
-<BR CLEAR="ALL"><P></P>
-
-The <I>shortest path weight</I> from vertex <i>u</i> to <i>v</i> is then
-
-<BR>
-<p></p>
-<DIV ALIGN="left">
-<i>delta (u,v) = min { w(p) : u --> v }</i> if there is a path from
-<i>u</i> to <i>v</i> <br>
-<i>delta (u,v) = infinity</i> otherwise.
-</DIV>
-<BR CLEAR="ALL"><P></P>
-
-A <I>shortest path</I> is any path who's path weight is equal to the
-<I>shortest path weight</I>.
-
-<P>
-There are several variants of the shortest path problem. Above we
-defined the <I>single-pair</I> problem, but there is also the
-<I>single-source problem</I> (all shortest paths from one vertex to
-every other vertex in the graph), the equivalent
-<I>single-destination problem</I>, and the <I>all-pairs problem</I>.
-It turns out that there are no algorithms for solving the single-pair
-problem that are asymptotically faster than algorithms that solve the
-single-source problem.
-
-<P>
-A <I>shortest-paths tree</I> rooted at vertex in graph <i>G=(V,E)</i>
-is a directed subgraph <G'> where <i>V'</i> is a subset
-of <i>V</i> and <i>E'</i> is a subset of <i>E</i>, <i>V'</i> is the
-set of vertices reachable from , <i>G'</i> forms a rooted tree with
-root , and for all <i>v</i> in <i>V'</i> the unique simple path from
-to <i>v</i> in <i>G'</i> is a shortest path from to <i>v</i> in . The
-result of a single-source algorithm is a shortest-paths tree.
-
-<P>
-
-<H2><a name="sec:network-flow-algorithms">Network Flow Algorithms</H2>
-
-<p>
-A flow network is a directed graph <i>G=(V,E)</i> with a
-<b><i>source</i></b> vertex <i>s</i> and a <b><i>sink</i></b> vertex
-<i>t</i>. Each edge has a positive real valued <b><i>capacity</i></b>
-function <i>c</i> and there is a <b><i>flow</i></b> function <i>f</i>
-defined over every vertex pair. The flow function must satisfy three
-contraints:
-
-<p>
-<i>f(u,v) <= c(u,v) for all (u,v) in V x V</i> (Capacity constraint) <br>
-<i>f(u,v) = - f(v,u) for all (u,v) in V x V</i> (Skew symmetry)<br>
-<i>sum<sub>v in V</sub> f(u,v) = 0 for all u in V - {s,t}</i> (Flow conservation)
-
-<p>
-The <b><i>flow</i></b> of the network is the net flow entering the
-sink vertex <i>t</i> (which is equal to the net flow leaving the
-source vertex <i>s</i>).<p>
-
-<i>|f| = sum<sub>u in V</sub> f(u,t) = sum<sub>v in V</sub> f(s,v)</i>
-
-<p>
-The <b><i>residual capacity</i></b> of an edge is <i>r(u,v) = c(u,v) -
-f(u,v)</i>. The edges with <i>r(u,v) > 0</i> are residual edges
-<i>E<sub>f</sub></i> which induce the residual graph <i>G<sub>f</sub>
-= (V, E<sub>f</sub>)</i>. An edge with <i>r(u,v) = 0</i> is
-<b><i>saturated</i></b>.
-
-<p>
-The <b><i>maximum flow problem</i></b> is to determine the maximum
-possible value for <i>|f|</i> and the corresponding flow values for
-every vertex pair in the graph.
-
-<p>
-A flow network is shown in <a href="#fig:max-flow">Figure
-8</a>. Vertex <i>A</i> is the source vertex and <i>H</i> is the target
-vertex.
-
-<P></P>
-<DIV ALIGN="center"><A NAME="fig:max-flow"></A><A NAME="1509"></A>
-<TABLE>
-<CAPTION ALIGN="BOTTOM"><STRONG>Figure 8:</STRONG> A Maximum Flow
-Network.<br> Edges are labeled with the flow and capacity
-values.</CAPTION>
-<TR><TD><IMG SRC="./figs/max-flow.gif" width="578" height="240"></TD></TR>
-</TABLE>
-</DIV><P></P>
-
-<p>
-There is a long history of algorithms for solving the maximum flow
-problem, with the first algorithm due to <a
-href="./bibliography.html#ford56:_maxim">Ford and Fulkerson</a>. The
-best general purpose algorithm to date is the push-relabel algorithm
-of <a
-href="./bibliography.html#goldberg85:_new_max_flow_algor">Goldberg</a>
-which is based on the notion of a <b><i>preflow</i></b> introduced by
-<a href="./bibliography.html#karzanov74:_deter">Karzanov</a>.
-
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../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/graph_traits.html

@@ -1,256 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: Graph Traits</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1><A NAME=""></A>
-<pre>
-graph_traits&lt;<a href="./Graph.html">Graph</a>&gt;
-</pre>
-</H1>
-
-Just like the <a
-href="http://www.sgi.com/tech/stl/iterator_traits.html">
-iterators</a> of STL, graphs have <b>associated types</b>.  As stated
-in the various <a href="./graph_concepts.html">graph concepts</a>, a
-graph has quite a few associated types: <tt>vertex_descriptor</tt>,
-<tt>edge_descriptor</tt>, <tt>out_edge_iterator</tt>, etc..  Any
-particular graph concepts will not require that all of the following
-associated types be defined. When implementing a graph class that
-fullfils one or more graph concepts, for associated types that are not
-required by the concepts, it is ok to use <tt>void</tt> as the type
-(when using nested typedefs inside the graph class), or to leave the
-typedef out of the <tt>graph_traits</tt> specialization for the graph
-class.
-
-<pre>
-  template &lt;typename Graph&gt;
-  struct graph_traits {
-    typedef typename Graph::vertex_descriptor      vertex_descriptor;
-    typedef typename Graph::edge_descriptor        edge_descriptor;
-    typedef typename Graph::adjacency_iterator     adjacency_iterator;
-    typedef typename Graph::out_edge_iterator      out_edge_iterator;
-    typedef typename Graph::in_edge_iterator       in_edge_iterator;
-    typedef typename Graph::vertex_iterator        vertex_iterator;
-    typedef typename Graph::edge_iterator          edge_iterator;
-
-    typedef typename Graph::directed_category      directed_category;
-    typedef typename Graph::edge_parallel_category edge_parallel_category;
-    typedef typename Graph::traversal_category     traversal_category;
-
-    typedef typename Graph::vertices_size_type     vertices_size_type;
-    typedef typename Graph::edges_size_type        edges_size_type;
-    typedef typename Graph::degree_size_type       degree_size_type;
-  };
-</pre>
-
-<h3>Where Defined</h3>
-
-<a href="../../../boost/graph/graph_traits.hpp"><tt>boost/graph/graph_traits.hpp</tt></a>
-
-<H3>Template Parameters</H3>
-
-<P>
-<TABLE border>
-<TR>
-<th>Parameter</th><th>Description</th>
-</tr>
-
-<TR><TD><TT>Graph</TT></TD>
-<TD>
-The graph type whose associated types are being accessed.
-</TD>
-</TR>
-
-</table>
-
-<h3>Model of</h3>
-
-<a
-href="http://www.sgi.com/tech/stl/DefaultConstructible.html">DefaultConstructible</a> and
-<a href="http://www.sgi.com/tech/stl/Assignable.html">Assignable</a>
-
-<h3>Type Requirements</h3>
-
-<ul>
-  <li><tt>Graph</tt> is a model of one of the <a
-  href="./graph_concepts.html">graph concepts</a>.
-</ul>
-
-<H2>Members</H2>
-
-<p>
-
-<table border>
-<tr>
-<th>Member</th><th>Description</th>
-</tr>
-
-<tr>
-<td><tt>
-vertex_descriptor
-</tt></td>
-<td>
-The type for the objects used to identity vertices in the graph.
-</td>
-</tr>
-
-<tr>
-<td><tt>
-edge_descriptor
-</tt></td>
-<td>
-The type for the objects used to identity edges in the graph.
-</td>
-</tr>
-
-<tr>
-<td><tt>
-adjacency_iterator
-</tt></td>
-<td>
-The type for the iterators that traverse the vertices adjacent
-to a vertex.
-</td>
-</tr>
-
-<tr>
-<td><tt>
-out_edge_iterator
-</tt></td>
-<td>
-The type for the iterators that traverse through the out-edges
-of a vertex.
-</td>
-</tr>
-
-<tr>
-<td><tt>
-in_edge_iterator
-</tt></td>
-<td>
-The type for the iterators that traverse through the in-edges
-of a vertex.
-</td>
-</tr>
-
-<tr>
-<td><tt>
-vertex_iterator
-</tt></td>
-<td>
-The type for the iterators that traverse through the complete vertex
-set of the graph.
-</td>
-</tr>
-
-<tr>
-<td><tt>
-edge_iterator
-</tt></td>
-<td>
-The type for the iterators that traverse through the complete edge
-set of the graph.
-</td>
-</tr>
-
-<tr>
-<td><tt>
-directed_category
-</tt></td>
-<td>
-This says whether the graph is undirected (<tt>undirected_tag</tt>)
-or directed (<tt>directed_tag</tt>).
-</td>
-</tr>
-
-<tr>
-<td><tt>
-edge_parallel_category
-</tt></td>
-<td>
-This says whether the graph allows parallel edges to be inserted
-(<tt>allow_parallel_edge_tag</tt>) or if it automatically removes
-parallel edges (<tt>disallow_parallel_edge_tag</tt>).
-</td>
-</tr>
-
-<tr>
-<td><tt>
-traversal_category
-</tt></td>
-<td>
-The ways in which the vertices in the graph can be traversed.
-The traversal category tags are: 
-<tt>incidence_graph_tag, adjacency_graph_tag,
-bidirectional_graph_tag, vertex_list_graph_tag,
-edge_list_graph_tag, vertex_and_edge_list_graph_tag,
-adjacency_matrix_tag</tt>. You can also create your own
-tag which should inherit from one of the above. 
-</td>
-</tr>
-
-<tr>
-<td><tt>
-vertices_size_type
-</tt></td>
-<td>
-The unsigned integer type used for representing the number of
-vertices in the graph.
-</td>
-</tr>
-
-<tr>
-<td><tt>
-edge_size_type
-</tt></td>
-<td>
-The unsigned integer type used for representing the number of
-edge in the graph.
-</td>
-</tr>
-
-<tr>
-<td><tt>
-degree_size_type
-</tt></td>
-<td>
-The unsigned integer type used for representing the degree
-of vertices in the graph.
-</td>
-</tr>
-
-</table>
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/history.html

@@ -1,102 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: History</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<h1>History of the Boost Graph Library</h1>
-
-The Boost Graph Library began its life as the Generic Graph Component
-Library (GGCL), a software project at the <a
-href="http://www.lsc.nd.edu">Lab for Scientific Computing (LSC)</a> at
-the University of Notre Dame, under the direction of Professor <a
-href="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</a>. The Lab's
-research directions include numerical linear algebra, parallel
-computing, and software engineering (including generic programming).
-
-<p>
-Soon after the Standard Template Library was released, work began at
-the LSC to apply generic programming to scientific computing.  The <a
-href="http://www.lsc.nd.edu/research/mtl">Matrix Template Library</a>
-(Jeremy Siek's masters thesis) was one of the first projects. Many of
-the lessons learned during construction of the MTL were applied to the
-design and implementation of the GGCL.
-
-<p>
-Graph algorithms play an important role in sparse matrix computations,
-so the LSC had a need for a good graph library. However, none of the
-available graph libraries (LEDA, GTL, Stanford GraphBase) were
-written using the generic programming style of the STL, and hence did
-not fulfill the flexibility and high-performance requirements of the
-LSC. Others were also expressing interest in a generic C++ graph
-library. During a meeting with Bjarne Stroustrup we were introduced to
-several people at AT\&T who needed such a library. There had also been
-earlier work in the area of generic graph algorithms, including some
-codes written by Alexander Stepanov, and Dietmar K&uuml;hl's masters
-thesis.
-
-<p>
-With this in mind, and motivated by homework assignments in his
-algorithms class, Jeremy began prototyping an interface and some graph
-classes in the spring on 1998. Lie-Quan Lee then developed the first
-version of GGCL, which became his masters thesis project.
-
-<p>
-The following year, Jeremy went to work for SGI with Alexander
-Stepanov and Matt Austern. During this time Alex's disjoint-sets based
-connected components algorithm was added to GGCL, and Jeremy began
-working on the concept documentation for GGCL similar to Matt's STL
-documentation.
-
-<p>
-While working at SGI, Jeremy heard about Boost and was excited to find
-a group of people interested in creating high-quality C++
-libraries. At boost there were several people interested in generic
-graph algorithms, most notably Dietmar K&uuml;hl.  Some discussions
-about generic interfaces for graph structures resulted in the a
-revision of GGCL which closely resembles the current Boost Graph
-Library interface.
-
-<p>
-On September 4, 2000 GGCL passed the Boost formal review and became
-the Boost Graph Library (BGL). The first release of BGL was
-September 27, 2000.
-
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 
-<!--  LocalWords:  gif ALT GGCL LSC Lumsdaine Siek's MTL LEDA GTL GraphBase STL
- -->
-<!--  LocalWords:  Bjarne Stroustrup hl's Quan SGI Stepanov Austern Alex's hl
- -->
-<!--  LocalWords:  Dietmar BGL siek htm Univ
- -->

doc/incident.html

@@ -1,83 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: incident</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1><A NAME="sec:incident"></A>
-<TT>incident</TT>
-</H1>
-
-<P>
-<DIV ALIGN="left">
-<TABLE CELLPADDING=3 border>
-
-<TR><TH ALIGN="LEFT"><B>Complexity:</B></TH>
-<TD ALIGN="LEFT"><i>O(1)</i>
-</TD>
-</TR>
-
-<TR><TH ALIGN="LEFT"><B>Where Defined:</B></TH>
-<TD ALIGN="LEFT">
-<a href="../../../boost/graph/graph_utility.hpp"><TT>boost/graph/graph_utility.hpp</TT></a>
-</TD>
-
-</TABLE>
-</DIV>
-
-<P>
-<PRE>
-  template &lt;class Graph&gt;
-  std::pair&lt;typename graph_traits&lt;Graph&gt;::vertex_descriptor,
-            typename graph_traits&lt;Graph&gt;::vertex_descriptor&gt;
-  incident(typename graph_traits&lt;Graph&gt;::edge_descriptor e, Graph& g)
-</pre>
-
-This function takes and edge descriptor and returns the pair of
-vertices that are <i>incident</i> to the edge. For directed graphs,
-the <tt>first</tt> vertex is the source and the <tt>second</tt> vertex
-is the target. This function is equivalent to the expression
-<tt>std::make_pair(source(e, g), target(e, g))</tt>.
-
-
-<h3>Example</h3>
-
-<pre>
-  edge_descriptor e;
-  vertex_descriptor u, v;
-  ...
-  tie(u, v) = incident(e, g);
-</pre>
-
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/incremental_components.html

@@ -1,426 +0,0 @@
-<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.
-  -->
-<Head>
-<Title>Boost Graph Library: Incremental Connected Components</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<H1>Incremental Connected Components</H1>
-
-<P>
-This section describes a family of functions and classes that work
-together to calculate the connected components of an undirected graph.
-The algorithm used here is based on the disjoint-sets (fast
-union-find) data structure&nbsp;[<A
-HREF="bibliography.html#clr90">8</A>,<A
-HREF="bibliography.html#tarjan83:_data_struct_network_algo">27</A>]
-which is a good method to use for situations where the graph is
-growing (edges are being added) and the connected components
-information needs to be updated repeatedly. This method does not cover
-the situation where edges are both added and removed from the graph,
-hence it is called <b><i>incremental</i></b><a
-href="bibliography.html#eppstein97:dynamic_graph">[42]</a> (and not
-fully dynamic). The disjoint-sets class is described in Section <A
-HREF="../../disjoint_sets/disjoint_sets.html">Disjoint Sets</A>.
-
-<P>
-The following five operations are the primary functions that you will
-use to calculate and maintain the connected components.  The objects
-used here are a graph <TT>g</TT>, a disjoint-sets structure <TT>ds</TT>,
-and vertices <TT>u</TT> and <TT>v</TT>.
-
-<P>
-
-<UL>
-<LI><TT>initialize_incremental_components(g, ds)</TT> 
-<BR>
-Basic initialization of the disjoint-sets structure. Each
-    vertex in the graph <TT>g</TT> is in its own set.
-</LI>
-<LI><TT>incremental_components(g, ds)</TT> 
-<BR>
-The connected components are calculated based on the edges in the graph
-    <TT>g</TT> and the information is embedded in <TT>ds</TT>.
-</LI>
-<LI><TT>ds.find_set(v)</TT> 
-<BR>
-Extracts the component information for vertex <TT>v</TT> from the
-    disjoint-sets.
-</LI>
-<LI><TT>ds.union_set(u, v)</TT> 
-<BR>
-Update the disjoint-sets structure when edge <i>(u,v)</i> is added to the graph.
-</LI>
-</UL>
-
-<P>
-
-<H3>Complexity</H3>
-
-<P>
-The time complexity for the whole process is <i>O(V + E
-alpha(E,V))</i> where <i>E</i> is the total number of edges in the
-graph (by the end of the process) and <i>V</i> is the number of
-vertices.  <i>alpha</i> is the inverse of Ackermann's function which
-has explosive recursively exponential growth. Therefore its inverse
-function grows <I>very</I> slowly. For all practical purposes
-<i>alpha(m,n) <= 4</i> which means the time complexity is only
-slightly larger than <i>O(V + E)</i>.
-
-<P>
-
-<H3>Example</H3>
-
-<P>
-Maintain the connected components of a graph while adding edges using
-the disjoint-sets data structure. The full source code for this
-example can be found in <a
-href="../example/incremental_components.cpp"><TT>examples/incremental_components.cpp</TT></a>.
-
-<P>
-<PRE>
-  // Create a graph
-  typedef adjacency_list &lt;vecS, vecS, undirectedS&gt; Graph;
-  typedef Graph::vertex_descriptor Vertex;
-  const int N = 6;
-  Graph G(N);
-  add_edge(0, 1, G);
-  add_edge(1, 4, G);
-
-  // create the disjoint-sets structure, which requires
-  // rank and parent vertex properties
-  std::vector&lt;Vertex&gt; rank(num_vertices(G));
-  std::vector&lt;Vertex&gt; parent(num_vertices(G));
-  typedef std::vector&lt;Graph::size_type&gt;::iterator Rank;
-  typedef std::vector&lt;Vertex&gt;::iterator Parent;
-  disjoint_sets&lt;Rank, Parent&gt; ds(rank.begin(), parent.begin());
-
-  // determine the connected components
-  // the results are embedded in the disjoint-sets structure
-  initialize_incremental_components(G, ds);
-  incremental_components(G, ds);
-
-  Graph::edge_descriptor e;
-  bool flag;
-
-  // Add a couple more edges and update the disjoint-sets
-  tie(e,flag) = add_edge(4, 0, G);
-  ds.union_set(4,0);
-
-  tie(e,flag) = add_edge(2, 5, G);
-  ds.union_set(2,5);
-    
-  cout &lt;&lt; "An undirected graph:" &lt;&lt; endl;
-  print_graph(G, get(vertex_index, G));
-  cout &lt;&lt; endl;
-    
-  Graph::vertex_iterator i,end;
-  for (tie(i,end) = vertices(G); i != end; ++i)
-    cout &lt;&lt; "representative[" &lt;&lt; *i &lt;&lt; "] = " &lt;&lt; 
-      ds.find_set(*i) &lt;&lt; endl;;
-  cout &lt;&lt; endl;
-
-  typedef component_index&lt;int&gt; Components;
-  Components components(parent.begin(), parent.end());
-
-  for (Components::size_type i = 0; i &lt; components.size(); ++i) {
-    cout &lt;&lt; "component " &lt;&lt; i &lt;&lt; " contains: ";
-    Components::value_type::iterator
-      j = components[i].begin(),
-      jend = components[i].end();
-    for ( ; j != jend; ++j)
-      cout &lt;&lt; *j &lt;&lt; " ";
-    cout &lt;&lt; endl;
-  }
-</PRE>
-
-<P>
-<hr>
-<p>
-
-<H2><A NAME="sec:initialize-incremental-components"></A>
-<TT>initialize_incremental_components</TT>
-</H2>
-
-<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">rank, parent (in disjoint-sets)</TD>
-</TR>
-<TR><TH ALIGN="LEFT"><B>Complexity:</B></TH>
-<TD></TD>
-</TR>
-</TABLE>
-</DIV>
-
-<P>
-<PRE>
-template &lt;class VertexListGraph, class DisjointSets&gt; 
-void initialize_incremental_components(VertexListGraph&amp; G, DisjointSets&amp; ds)
-</PRE>
-
-<P>
-This prepares the disjoint-sets data structure for the incremental
-connected components algorithm by making each vertex in the graph a
-member of its own component (or set).
-
-<P>
-
-<H3>Where Defined</H3>
-
-<P>
-<a href="../../../boost/graph/incremental_components.hpp"><TT>boost/graph/incremental_components.hpp</TT></a>
-
-<p>
-<hr>
-<P>
-
-<H2><A NAME="sec:incremental-components"></A>
-<TT>incremental_components</TT>
-</H2>
-
-<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">rank, parent (in disjoint-sets)</TD>
-</TR>
-<TR><TH ALIGN="LEFT"><B>Complexity:</B></TH>
-<TD ALIGN="LEFT"><i>O(E)</i></TD>
-</TR>
-</TABLE>
-</DIV>
-
-<p>
-<PRE>
-template &lt;class EdgeListGraph, class DisjointSets&gt;
-void incremental_components(EdgeListGraph&amp; g, DisjointSets&amp; ds)
-</PRE>
-
-<P>
-This function calculates the connected components of the graph,
-embedding the results in the disjoint-sets data structure.
-
-<P>
-
-<H3>Where Defined</H3>
-
-<P>
-<a href="../../../boost/graph/incremental_components.hpp"><TT>boost/graph/incremental_components.hpp</TT></a>
-
-<P>
-
-<H3>Requirements on Types</H3>
-
-<P>
-
-<UL>
-<LI>The graph type must be a model of <a href="./EdgeListGraph.html">EdgeListGraph</a>.
-</LI>
-</UL>
-
-<P>
-<hr>
-<p>
-
-<H2><A NAME="sec:same-component">
-<TT>same_component</TT></A>
-</H2>
-
-<P>
-<DIV ALIGN="left">
-<TABLE CELLPADDING=3 border>
-<TR><TH ALIGN="LEFT"><B>Properties:</B></TH>
-<TD ALIGN="LEFT">rank, parent (in disjoint-sets)</TD>
-</TR>
-<TR><TH ALIGN="LEFT"><B>Complexity:</B></TH>
-<TD ALIGN="LEFT"><i>O(alpha(E,V))</i></TD>
-</TR>
-</TABLE>
-</DIV>
-
-<P>
-<PRE>
-template &lt;class Vertex, class DisjointSet&gt;
-bool same_component(Vertex u, Vertex v, DisjointSet&amp; ds)
-</PRE>
-
-<P>
-This function determines whether <TT>u</TT> and <TT>v</TT> are in the same
-component.
-
-<P>
-
-<H3>Where Defined</H3>
-
-<P>
-<a href="../../../boost/graph/incremental_components.hpp"><TT>boost/graph/incremental_components.hpp</TT></a>
-
-<P>
-
-<H3>Requirements on Types</H3>
-
-<P>
-
-<UL>
-<LI><TT>Vertex</TT> must be compatible with the rank and parent
-    property maps of the <TT>DisjointSets</TT> data structure.
-</LI>
-</UL>
-
-<P>
-<hr>
-<p>
-
-<H2><A NAME="sec:component-index"></A>
-<TT>component_index</TT>
-</H2>
-
-<p>
-<PRE>
-component_index&lt;Index&gt;
-</PRE>
-
-<P>
-The is a class that provides an STL container-like view for the
-components of the graph. Each component is a container-like object,
-and the <TT>component_index</TT> object provides access to the
-component objects via <TT>operator[]</TT>. A <TT>component_index</TT>
-object is initialized with the parents property in the disjoint-sets
-calculated from the <TT>incremental_components()</TT> function.
-
-<P>
-
-<H3>Where Defined</H3>
-
-<P>
-<a href="../../../boost/graph/incremental_components.hpp"><TT>boost/graph/incremental_components.hpp</TT></a>
-
-<P>
-
-<H3>Members</H3>
-
-<P>
- 
-<table border>
-
-<tr>
-<th>Member</th> <th>Description</th>
-</tr>
-
-<tr>
-<td><tt>size_type</tt></td>
-<td>The type used for representing the number of components.</td>
-</tr>
-
-
-<tr>
-<td><tt>value_type</tt></td>
-<td>
-The type for a component object. The component type has the following members.
-</td>
-</tr>
- 
-<tr>
-<td><tt>value_type::value_type</tt></td>
-<td>
-The value type of a component object is a vertex ID.
-</td>
-</tr>
-
-<tr>
-<td><tt>value_type::iterator</tt></td>
-<td>
-This iterator can be used to traverse all of the vertices
-in the component. This iterator dereferences to give a vertex ID.
-</td>
-</tr>
-
-<tr>
-<td><tt>value_type::const_iterator</tt></td>
-<td>
-The const iterator.
-</td>
-</tr>
-
-<tr>
-<td><tt>value_type::iterator value_type::begin() const</tt></td>
-<td>
-Return an iterator pointing to the first vertex in the component.
-</td>
-</tr>
-
-<tr>
-<td><tt>value_type::iterator value_type::end() const</tt></td>
-<td>
-Return an iterator pointing past the end of the last vertex in the
-component.
-</td>
-<tr>
-
-<tr>
-<td>
-<tt>
-template &lt;class ComponentsContainer&gt;
-component_index(const ComponentsContainer&amp; c)
-</tt>
-</td>
-<td>
-Construct the <TT>component_index</TT> using the information
-from the components container <TT>c</TT> which was the result
-of executing <TT>connected_components_on_edgelist</TT>.
-</td>
-</tr>
-
-<tr>
-<td><tt>value_type operator[](size_type i)</tt></td>
-<td>
-Returns the <TT>i</TT>th component in the graph.
-</td>
-</tr>
-
-<tr>
-<td><tt>size_type component_index::size()</tt></td>
-<td>
-Returns the number of components in the graph.
-</td>
-
-</table> 
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 

doc/index.html

@@ -1,289 +1,19 @@
-<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.
-  -->
-<Head>
-<Title>The Boost Graph Library</Title>
-<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
-        ALINK="#ff0000"> 
-<IMG SRC="../../../c++boost.gif" 
-     ALT="C++ Boost" width="277" height="86"> 
-
-<BR Clear>
-
-<h1>The Boost Graph Library (BGL)
-<a href="http://cseng.awl.com/book/0,3828,0201729148,00.html">
-<img src="bgl-cover.jpg" ALT="BGL Book" ALIGN="RIGHT"></a>
-</h1>
-
-<P>
-Graphs are mathematical abstractions that are useful for solving many
-types of problems in computer science. Consequently, these
-abstractions must also be represented in computer programs.  A
-standardized generic interface for traversing graphs is of utmost
-importance to encourage reuse of graph algorithms and data structures.
-Part of the Boost Graph Library is an interface for how the structure
-of a graph can be accessed using a generic interface that hides the
-details of the graph data structure implementation. This is an
-``open'' interface in the sense that any graph library that implements
-this interface will be interoperable with the BGL generic algorithms
-and with other algorithms that also use this interface. BGL provides
-some general purpose graph classes that conform to this interface, but
-they are not meant to be the ``only'' graph classes; there certainly
-will be other graph classes better for certain situations.  We believe
-that the main contribution of the BGL is the formulation of this
-interface.
-
-<P>
-The BGL graph interface and graph components are <I>generic</I> in the
-same sense as the the Standard Template Library (STL)&nbsp;[<A
-HREF="bibliography.html#austern99:_gener_progr_stl">2</A>].
-
-In the following sections we review the role that generic programming
-plays in the STL and compare that to how we applied generic
-programming in the context of graphs.
-
-<P>
-Of course, if you are already are familiar with generic programming,
-please dive right in! Here's the <a
-href="./table_of_contents.html">Table of Contents</a>.
-
-<P>
-The source for the BGL is available as part of the Boost distribution
-which you can <a href="http://www.boost.org/more/download.html">
-download from here</a>.
-
-<H2>Genericity in STL</H2>
-
-<P>
-There are three ways in which the STL is generic.  
-
-<P>
-
-<H3>Algorithm/Data-Structure Interoperability</H3>
-
-<P>
-First, each algorithm is written in a data-structure neutral way,
-allowing a single template function to operate on many different
-classes of containers. The concept of an iterator is the key
-ingredient in this decoupling of algorithms and data-structures.  The
-impact of this technique is a reduction in the STL's code size from
-<i>O(M*N)</i> to <i>O(M+N)</i>, where <i>M</i> is the number of
-algorithms and <i>N</i> is the number of containers. Considering a
-situation of 20 algorithms and 5 data-structures, this would be the
-difference between writing 100 functions versus only 25 functions! And
-the differences continues to grow faster and faster as the number of
-algorithms and data-structures increase.
-
-<P>
-
-<H3>Extension through Function Objects</H3>
-
-<P>
-The second way STL is generic is that its algorithms and containers
-are extensible. The user can adapt and customize the STL through the
-use of function objects. This flexibility is what makes STL such a
-great tool for solving real-world problems. Each programming problem
-brings its own set of entities and interactions that must be
-modeled. Function objects provide a mechanism for extending the STL to
-handle the specifics of each problem domain.
-
-<P>
-
-<H3>Element Type Parameterization</H3>
-
-<P>
-The third way that STL is generic is that its containers are
-parameterized on the element type. Though hugely important, this is
-perhaps the least ``interesting'' way in which STL is generic.
-Generic programming is often summarized by a brief description of
-parameterized lists such as <TT>std::list&lt;T&gt;</TT>. This hardly scratches
-the surface!
-
-<P>
-
-<H2>Genericity in the Boost Graph Library</A>
-</H2>
-
-<P>
-Like the STL, there are three ways in which the BGL is generic.
-
-<P>
-
-<H3>Algorithm/Data-Structure Interoperability</H3>
-
-<P>
-First, the graph algorithms of BGL are written to an interface that
-abstracts away the details of the particular graph data-structure.
-Like the STL, the BGL uses iterators to define the interface for
-data-structure traversal. There are three distinct graph traversal
-patterns: traversal of all vertices in the graph, through all of the
-edges, and along the adjacency structure of the graph (from a vertex
-to each of its neighbors). There are separate iterators for each
-pattern of traversal.
-
-<P>
-This generic interface allows template functions such as <a
-href="./breadth_first_search.html"><TT>breadth_first_search()</TT></a>
-to work on a large variety of graph data-structures, from graphs
-implemented with pointer-linked nodes to graphs encoded in
-arrays. This flexibility is especially important in the domain of
-graphs. Graph data-structures are often custom-made for a particular
-application. Traditionally, if a programmer wants to reuse an
-algorithm implementation they must convert/copy their graph data into
-the graph library's prescribed graph structure.  This is the case with
-libraries such as LEDA, GTL, Stanford GraphBase, and especially true
-of graph algorithms written in Fortran. This severely limits the reuse
-of their graph algorithms.
-
-<P>
-In contrast, custom-made (or even legacy) graph structures can be used
-as-is with the generic graph algorithms of BGL using <I>external
-adaptation</I> (see Section <A HREF="./leda_conversion.html">How to
-Convert Existing Graphs to BGL</A>).  External adaptation wraps a new
-interface around a data-structure without copying and without placing
-the data inside adaptor objects.  The BGL interface was carefully
-designed to make this adaptation easy. To demonstrate this, we have
-built interfacing code for using LEDA graphs, Stanford GraphBase
-graphs, and even Fortran-style arrays in BGL graph algorithms.
-
-<P>
-
-<H3>Extension through Visitors</H3>
-
-<P>
-Second, the graph algorithms of BGL are extensible. BGL introduces the
-notion of a <I>visitor</I> which is just a function object with
-multiple methods.  In graph algorithms there are often several key
-``event points'' at which it is useful to insert user-defined
-operations. The visitor object has a different method that is invoked
-at each event point. The particular event points and corresponding
-visitor methods depend on the particular algorithm.  They often
-include methods like <TT>start_vertex()</TT>,
-<TT>discover_vertex()</TT>, <TT>examine_edge()</TT>,
-<tt>tree_edge()</tt> and <TT>finish_vertex()</TT>.
-
-<P>
-
-<H3>Vertex and Edge Property Multi-Parameterization</H3>
-
-<P>
-The third way that BGL is generic is analogous to the parameterization
-of the element-type in STL containers, though again the story is a bit
-more complicated for graphs. We need to associate values with both the
-vertices and the edges of the graph (we will call an associated value
-a property).  In addition, it will often be necessary to associate
-multiple properties with each vertex and edge, which is what we mean
-by multi-parameterization. Similar to how the <TT>std::list&lt;T&gt;</TT>
-class has the parameter <TT>T</TT> for its element type, BGL graph
-classes have template parameters for vertex and edge ``properties''. A
-property specifies the parameterized type of the property and also assigns
-an identifying tag to the property, which is used to distinguish
-between the multiple properties. The property value attached to a
-particular vertex or edge can be obtained via a <I>property
-map</I>, of which there is one for each property.
-
-<P>
-Traditional graph libraries and graph structures fall down when it
-comes to the parameterization of graph properties. This is one of the
-primary reasons that graph data-structures must be custom-built for
-applications. The parameterization of properties in the  BGL graph
-classes makes them well suited for re-use.
-
-<p>
-
-<H2>Algorithms</H2>
-
-<P>
-The BGL algorithms consist of a core set of algorithm <I>patterns</I>
-(implemented as generic algorithms) and a larger set of graph
-algorithms. The core algorithm patterns are
-
-<P>
-
-<UL>
-<LI>Breadth First Search
-</LI>
-<LI>Depth First Search
-</LI>
-<LI>Uniform Cost Search
-</LI>
-</UL>
-
-<P>
-The algorithm patterns by themselves do not compute any meaningful
-quantities over graphs, they are merely building blocks for
-constructing graph algorithms. The graph algorithms in  BGL currently
-include
-
-<P>
-
-<UL>
-<LI>Dijkstra's Shortest Paths</LI>
-<LI>Bellman-Ford Shortest Paths</LI>
-<LI>Johnson's All-Pairs Shortest Paths</LI>
-<LI>Kruskal's Minimum Spanning Tree</LI>
-<LI>Prim's Minimum Spanning Tree</LI>
-<LI>Connected Components</LI>
-<LI>Strongly Connected Components</LI>
-<LI>Dynamic Connected Components (using Disjoint Sets)</LI>
-<LI>Topological Sort</LI>
-<LI>Transpose</LI>
-<LI>Reverse Cuthill Mckee Ordering</LI>
-<LI>Smallest Last Vertex Ordering</LI>
-<LI>Sequential Vertex Coloring</LI>
-</UL>
-
-<P>
-
-<H2>Data Structures</H2>
-
-<P>
-BGL currently provides two graph classes that implement a generalized
-adjacency list and an edge list adaptor.
-
-<P>
-
-<UL>
-<LI><TT>adjacency_list</TT></LI>
-<LI><TT>adjacency_matrix</TT></LI>
-<LI><TT>edge_list</TT></LI>
-</UL>
-
-<P>
-The <TT>adjacency_list</TT> class is the general purpose ``swiss army
-knife'' of graph classes. It is highly parameterized so that it can be
-optimized for different situations: the graph is directed or
-undirected, allow or disallow parallel edges, efficient access to just
-the out-edges or also to the in-edges, fast vertex insertion and
-removal at the cost of extra space overhead, etc.
-
-<P>
-The <TT>edge_list</TT> class is an adaptor that takes any kind of edge
-iterator and implements an <a href="./EdgeListGraph.html">EdgeListGraph</a>.
-
-
-<br>
-<HR>
-<TABLE>
-<TR valign=top>
-<TD nowrap>Copyright &copy 2000-2001</TD><TD>
-<A HREF="../../../people/jeremy_siek.htm">Jeremy Siek</A>,
-Indiana University (<A
-HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
-<A HREF="../../../people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
-<A HREF=http://www.osl.iu.edu/~lums>Andrew Lumsdaine</A>,
-Indiana University (<A
-HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
-</TD></TR></TABLE>
-
-</BODY>
-</HTML> 
+<html>
+    <head>
+        <title>Boost.Graph</title>
+        <meta http-equiv="refresh" content="0; URL=../../../doc/antora/graph/index.html">
+    </head>
+    <body>
+        Automatic redirection failed, please go to
+        <a href="../../../doc/antora/graph/index.html">../../../doc/antora/graph/index.html</a>
+        <hr>
+        <tt>
+        Boost.Graph<br>
+        <br>
+        Distributed under the Boost Software License, Version 1.0.
+        (See accompanying file LICENSE_1_0.txt or copy at
+        <a href=http://www.boost.org/LICENSE_1_0.txt>http://www.boost.org/LICENSE_1_0.txt</a>) <br>
+        <br>
+        </tt>
+    </body>
+</html>