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

This implements access to filtered graphs either with boolean-indexed
array or masked arrays, through the 'fa' and 'ma' attributes,
respectively.

For some reason sphinx looks for a graph_tool module inside graph_tool.
This commit defines such a thing.

This fixes a bug where the filters where not correctly copied from the
base graph.

Now properties can be copied from vertices which are not identical
(e.g. from unfiltered to filtered graphs, etc). This fixes a problem
with graph copying and pruning, where the properties were not correclty
copied.

Now, statements like:

   prop[v].a = foo

are perfectly valid (if prop[v] is a vector type).

This also includes proper test strings.

This moves the documentation out of the constructor, and into the class
definition.

This allows easy creation of unfiltered copies of filtered graphs.

Now if a GraphView object is deleted, any property map created for it
reverts its ownership to the base Graph object. This eliminates the
problem of property maps created with transient GraphView objects.

Now GraphView.base points to the underlying, unfiltered, base graph,
even if "g" is another GraphView instance.

This makes sphinx's autodoc slightly happier.

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

Added more DOI links to references, and other cosmetic changes.

The arrays returned by PropertyMap.get_array() are now PropertyArray
instances, which keep track of the PropertyMap data, and are able to
detect when it changes, and raise a ValueError exception. As such, it
becomes impossible to read or write to non-allocated memory if an array
becomes invalid.

This completes all the documentation up to this point.

These functions group several scalar properties into one vector
properties, and ungroup a vector property into several scalar
properties.

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.

This prints useful library information.

Import numpy and scipy before everything to avoid weird segmentation
faults depending on the order things are imported.

This modified several docstrings and introduces a quick-start guide.

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.

Avoids having to do

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

each time. Now one can do simply,

    g = load_graph("foo")

Fantastic.

Now graphml files properly contain all the supported value types, which
are all perfectly preserved when read (floating point data is now saved
in hexadecimal format). Several other improvements were made, such as
the ability to read and write to python file-like objects.

It is also now possible to have arbitrary python object properties, and
store them persistently (which is done internally with the pickling
interface).

vector<bool> was totally abolished, since its implementation is quite
broken. See: http://www.gotw.ca/publications/N1211.pdf and
http://www.gotw.ca/publications/N1185.pdf Now a uint8_t (aka. char) is
used in graph properties instead of a bool.

Graph types can now be fully pickled (this may not be feasible
memory-wise if the graph is too large, since the whole XML
representation is dumped to a string before it is saved on disc).

This commit splits libraph_tool into different libraries:
 
   - libgraph_tool_core
   - libgraph_tool_clustering (*)
   - libgraph_tool_community (*)
   - libgraph_tool_correlations (*)
   - libgraph_tool_distance (*)
   - libgraph_tool_generation (*)
   - libgraph_tool_layout (*)
   - libgraph_tool_misc (*)
   - libgraph_tool_stats (*)

It also adds the python sub-module 'test', which provides extensive unit
testing of the core functionality. The core library is fully functional
and all test pass successfully.

(*) -> module needs to be ported to new refactoring, and does not yet build

Everything was moved into the graph_tool directory, which should have,
after installation, the following structure:

graph_tool/                          Top-level package
      __init__.py                    Initialize the graph_tool package
      libgraph_tool.so               libgraph_tool submodule
      libgraph_tool.la               libtool file for libgraph_tool
      include/                       C++ include files for dynamically
                                     compiled code

Some visibility voodoo is necessary to ensure that RTTI work properly
across DSO boundaries, which is necessary to properly handle dynamic
property maps and such. Additionally, the action template must have a
different name each time the action code changes, to avoid additional
weirdness.

This also adds some other utility functions/typedefs to make writing
"inline" c++ code easier.

add_edge_property() should return a edge property not a vertex_property