This also implements direct manipulation of OpenMP settings (schedule
and number of threads) via python.

This makes edge deletion O(1) if fast edge deletion is enabled for the
graph.

Use schedule(static, 100), to reduce overhead with small graphs in the
majority of cases.

This fixes ticket #131, and includes a 'fast' O(k) option, which
changes the vertex index ordering.

Dumping boost::adjacency_list<> improves memory usage by a factor of
two, and also slightly improves performance in some cases.

An attempt no longer is made to reuse edge indexes in a contiguous
fashion.

This also makes all Edge classes inherit from the same base class of the
same name.

This fixes tickets #94 and #95

This works around a regression introduced in boost 1.48, relating to the
edge descriptors of reversed graphs.

See: https://svn.boost.org/trac/boost/ticket/6391

This better organizes the documentation of the Graph class and provides
other small fixes.

This implements a GraphView class which allows for convenient,
independent filtering graphs.

This enables support for older versions of GCC (>=4.2), by falling back
to the boost tr1 implementation when the GCC version is less than 4.4.

This fixes a crash when a "valid" copy of an invalid edge descriptor is
removed from the graph. Now the invalidity of the descriptor is detected
and exposed.

This fixes an obvious problem, where the graph gets deleted, and the
descriptors are still lying around. Usage of orphaned descriptors will
now just raise a ValueError.

The __repr__ function of Edge, Vertex, and PropertyMap now give
something more informative about each object.

This is a large commit which replaces lambda::bind with boost::bind in
most parts of the code. This improves compilation time, and slightly
decreases compilation memory usage in some cases.

No longer only thrown GraphError upon any error, but instead throw
specific exceptions which are more meaninful and are mapped to standard
python exceptions, such as IOError, ValueError and RuntimeError.

The following conversions are now possible: int(v) and tuple(e), where v
and e are Vertex and Edge instances, respectively.

Thins changes the graph filtering code slightly to wrap graph types with
GraphWrap, which automatically updates the edge index list when edges
are removed and added to the graph.

This also changes how graphs are passed to algorithms, which is now by
reference instead of pointer. (hence this touches lots of code, but
changes are trivial)

Add support for v.{out|in}_neighbours(), for direct iteration over the
neighbours, as well as v.all_edges() and v.all_neighbours(). This also
properly exports the Vertex and Edge classes, with docstrings.

This includes a new vector property map type (fast_vector_property_map)
which has optional disabling of bounds checking, through its associate
map type (unchecked_fast_vector_property_map). This should improve
performance on algorithms which depend on tight loops which access
property maps.

Bounds checking is only disabled locally just before the algorithms run,
and proper care is taken for bounds checking _beforehand_. The property
maps exposed to python still have internal bounds checking.

i.e. g.degree_property_map("in") will create and return a vertex property map
which corresponds to the in-degrees of the vertices. This is useful for
temporarily modifying or getting an array of degrees.

This makes operations on graphs more flexible in some circumstances.

This fixes a rather central bug, which causes duplicated indexes if
edges are removed and then new ones are added. Edge indexes are now
recycled as they are removed and then new ones are added. This still
guarantees O(1) complexity when adding or removing edges.

This commit removes the internal property maps from the GraphInterface
class, and makes all property maps external by default. The internal
property maps were moved to the python layer.