Unnecessary dynamic polymorphism is replaced by static polymorphism, in
the definitions of the rewiring strategies.

This also creates the misc sub-module. This may be re-organized in the
future.

Restructure the rewiring code, introducing further abstraction through
class inheritance.

Both uncorrelated and correlated cases draw edges directly.
This has actually proven faster than drawing vertices for the correlated
case, since realizing that indexes could be stored instead of edges.
Doing so avoids changes in the pool of candidate edges, which in turn
removes the need to rebuild it for each edge to rewire.
Consequently, it also makes the uncorrelated case a lot quicker.

In the uncorrelated undirected case, the new code also fixes a serious
bug: when building the edge pool, only one end of each edge was looked
at, because the "edges" vector is not equivalent to drawing all
out_edges from all vertices, as is done now.

This contains at the moment functions to perform basic vertex and edge
searches.

This allows specifying where numpy and scipy are installed, which can be
useful when installing graph_tool in a different location.

This adds missing uint64_t type to the list o supported numpy types.

This allows to import all submodules from graph_tool with one command,
e.g.,

   from graph_tool.all import *

Add $(srcdir) to include paths in AM_CPPFLAGS so that we can
compile the program writing all targets into a directory separate
from the sources.
This is done simply by creatig a subdirectory of the project root
and running "../configure" and "make" inside it.

This is a re-implementation based on new histogram code, which does not
build a 2D histogram, and is thus more exact and uses less memory.

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.

Simplify autogen.sh and remove ltmain.sh from repository, which should
be included as necessary from libtoolize.

Avoids having to do

    g = Graph()
    g.load("foo")

each time. Now one can do simply,

    g = load_graph("foo")

Fantastic.

Use weakrefs to keep track of known property maps in graphs, and owner
graphs in property maps to avoid circular references, which may lead to
memory leaks.

This also fixes a vertex removal bug.

This adds a graph_draw() functions which draws graphs in variety of
layouts and formats, and also to the screen, using the python graphviz
bindings.

Fix possible deadlock condition in random graph generation with
no_parallel and/or no_self_loops.

Graphs are now exactly copied, including filter state and filter
property maps.

Use tr1::tuple instead of boost::tuple to get around maximum tuple size
limit (this requires GCC 4.3). Introduce get_prop<> template function to
facilitate access of property maps from inline C++ code.

Also, get rid of g.underlying_graph(), and rely on "private" variable
g._Graph__graph instead.

Betweenness centrality should be differently normalized for undirected
and directed graphs, i.e., (n-2)*(n-1)/2 vs. (n-2)*(n-1),
respectively. Also, edge centrality should be respectively normalized
with n*(n-1)/2 and n*(n-1).

No longer functional or relevant.

A new 'clustering' sub-module was created.

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.

This is to avoid a common error of not being able to correctly normalize
a histogram because of truncated integer division.