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.

This adds vertex_average() and edge_average() to the stats module.

This makes operations on graphs more flexible in some circumstances.

This includes the community sub-module.

Reduce duplication of code for loading C++ modules.

Add global variables to configure.ac, to avoid unnecessary multiple
definitions.

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.