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

This enables the acceptance of numpy types such as numpy.int64 as
parameters to functions taking C++ integers or floats.

The filtered array returned now also reflects the vertex filtering, so that
it corresponds only to actually visible edges in the graph, not only
those explicitly selected via an edge filter.

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

The object may be globally reset via the seed_rng() function.

After the removal of filtered vertices via Graph.purge_vertices(), the
values of known property maps are now kept consistent with the
unmodified graph.

This works around a compilation bug in Apple GCC 4.2 + Macports.

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

Now, whenever GraphWrap is being used, the property maps are always
in "checked" mode.

These functions/properties provide more information and control about
edge indexing, which might be useful.

The reserved size for the array was set to g.num_edges(), but it should
be set to the maximum edge index + 1, since some edges might have been
deleted.

Now vector types of property maps can be accessed as arrays with the
get_array() and 'a' property, just like scalar property maps.

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.

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

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.

This prints useful library information.

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)

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.

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.