This finally fixes in the bug addressed by commit 309ddbbd, where
parallel edges could be erroneously created. In fact, the bug was more
serious: The source and target edge lists always pointed to the same
list (in the uncorrelated case, but could occasionally happen for the
correlated case also) which got shuffled during iteration. Since the
shuffling of one list interfered with the shuffling of the other, some
combinations of source and target edges could simply never be
considered... This commit forces both lists to always be independent.

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)

This was not working due to filtering semantics modifications.

This implements an efficient motif counting algorithm.

Edge index housekeeping was not preserved during copy.

This fixes bug where boost overlay files were not being used, when not
compiling from source dir.

The edge index housekeeping was not performed on edges which were
deleted due to vertex removal.

This provides a more convenient way of deleting vertices or edges
according to a simple criterion.

Make sure libtool is properly modified, by doing it last in
configure.ac.

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 adds the centrality module, which supports betweenness, eigentrust,
pagerank and absolute trust.

This makes the naming more sensible.

It now does not implies automatically "always_directed".

In some circumstances, the test for parallel edges would fail to detect
one, if it involved another "new" edge and one of the current ones being
rewired.

This commit also removes the requirement that edge indexes be continuous
in the range [0, num_edges(g)), which is not in general the case.

The seed option is now correctly interpreted.

The seed option is now properly passed to graphviz.

This includes the missing function declarations for edge and graph
properties.

Property maps of value type "string" do not return an array, since the
numpy string and std::string are different things.

graph_rewiring.cc: use static_cast<rng_t::result_type> instead of
uint32_t to convert the seed value for the rng_t constructor, so
the code becomes compatible with any rng_t.

Now inline() automatically converts known variables (such as property
maps) and defaults to boost::python objects, instead of scxx objects.

The code now is only generated for the current filtered, reversed and/or
directed status of the graph, reducing compile time and binary size.

Edge modification (remove and add) is now protected by a GraphWrap
class, which takes care of the edge index housekeeping, which does not
need to be done by hand anymore.

The function is also no longer bound to one graph, and can take an
arbitrary number of variables of known or unknown types, including
graphs.

Now all symbols are exported by default, except those strictly marked
as hidden.

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.

e.g., g.save("~/foo.xml")

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.

A property map object has now a get_array() member which returns an internally
owned array pointing to the property values.

Allow direct specification of vertex size, which accepts property maps,
and a couple of bug fixes.