This implements a utility function to determine the geometrical extents of a
set of points.

So far this really only covers insertion.

Entry impls Positionable, but any user-defined type may do so as well.

Many items in the tree module are mere implementation details and do not need
to be exposed publicly.

A separate structure can be constructed from the tree to associate arbitrary
data from a closure to each node. On this structure one can then execute
computational queries.

Also it is no longer unsafe as this is not quite the right use case for that
keyword.

This slightly changes the semantics, but no test was looking into this
peculiarity so it's okay to remove it.

There are two traits: Tree defines tree construction alone, whereas TreeWalk
wraps up computational queries on the trees.

This is arguably the more useful quantity than the extent (i.e. the
half-width).

The construction routines of Node have been integrated into NodeWithData to
form a new type NTree. The construction benchmarks have been adapted. The query
functionality does not work yet.

All tests have been reinstated and run successfully.

Tree interface

The operational behaviour of a tree is defined by what was TreeWalk before.
Hence, TreeWalk has been renamed to Tree. The former Tree trait was removed on
the other hand, as the constructors it defines do not hold generally. One may
for example write a tree without associated data (such as the current Node) and
still implement Tree<P, N, O, ()> for it.

Every tree should at least provide information about its structure and
geometry, so that one can write generic algorithms that directly work with the
structure outside the tree implementation.

This separates these concerns and leads to a cleaner interface. For convenience
and clear semantics two new trivial wrapper traits `Tree` and `PureTree` have
been added to comprise the functionality that makes up trees with and without
associated data.

This also allows to benchmark `PureNTree` versus `NTree`.

Common tree abstractions now live in the `tree` module, the
dimension-unspecific implementations in `ntree` and `util` now also contains
`Positionable` and `Entry` as they fit nowhere else (although they might
warrant another module at some point.

It is not necessary to deal with the accumulation of values in the query
implementations. It is simpler to pass some callback that handles state changes
by closing over its environment.

Restructure traits

Update documentation

Integrate with Travis CI

There is both a compilable Cargo project and a short excerpt in the readme for
demonstrative purposes.

Add gravity calculation as an example

NodeState is not hard-coded to use a Vec any more. For generic programming we
may want to impose trait bounds on the container in the future.

Fixes milibopp#7.

Abstract container in NodeState

These closures can be inlined and cause less indirection. This seems to speed
up affected benchmarks by about a third, which is a decent improvement.

Fixes milibopp#8.

Unboxed closures

The bug is [1] and it ought to be fixed at some point.

[1] rust-lang/rust#17257

Disable debug info to workaround compiler bug

Include build status in readme

The script was indented too much.

Fix Travis CI setup

Users of acacia should not need to be aware of its testing infrastructure and
currently acacia does not implement quickcheck traits to export.

Reduce quickcheck to a dev-dependency

They are fundamental parts of the generic tree infrastructure, and the
implementations depend on `Positionable`. `Entry` was renamed to `Positioned`
to make its purpose clearer. Furthermore, the documentation of these types is
now complete.

This makes sense now to prevent regressions as the util module is also fully
documented after moving out undocumented items.

This is useful if one wants to use the tree as a view performing computations
on separate data structures.

Restructure the Positionable trait

Use unboxed closures in readme

Update to latest Rust nightlies

The trait infrastructure now avoids parametrization over type parameters,
favouring associated types instead. To reuse associated type specifications,
ObjectQuery inherits Node and DataQuery inherits AssociatedData. Also note that
the Tree/PureTree traits have been removed, as they are fairly superfluous
given this new trait hierarchy.

This precludes some hypothetical use cases such as having a single tree
structure that can be viewed trivially as a tree in multiple senses. As it is
possible to create newtypes for such applications, the ergonomic benefits of
not having to deal with an explosion of type parameters outweigh this.

Fixes milibopp#16.

Associated types

Fix and continuously integrate gravity example

The gravity test cases are fairly involved integration tests. Therefore they
were moved out of tree as integration tests. This keeps the code base a bit
more organized.

Extract gravity tests from library

Now it can harbour any type implementing some notion of order and a mid point.

This is abstracted over its dimension using macros now.

The tree implementations have been stripped completely of their specialized
geometry code. The trait infrastructure now also refers to partitions instead
of a node center and width.

Consequentially the util module was removed, as its functionality was no longer
relevant. Note though, that as a replacement new functions are required to
compute a partition that encompasses a set of positions.

The test suite is currently does not work, as the relevant partitioning schemes
have to be reimplemented.

The items are reexported to retain the apparent structure.

They are exposed as getters now and the constructor ensures a positive,
non-zero width.

Dispatch is now a partition method with a (slow) default implementation. The
benchmarks have slightly improved, as a custom implementation of this dispatch
mechanism avoids having to iterate over all subpartitions.

To make this ergonomic, there is now a macro to generate the code that tests
the proposition that some type implements Partition correctly.

Abstraction of partitioning logic

Export Arbitrary impls as optional feature

Transition to Rust-1.0.0 alpha

Update readme to new API

Complete package metadata in Cargo.toml

This helps to distinguish, by which proposition check a test failure was
caused, while not having to split this in separate macros. The downside of
this change are the public reexports required by the macro system.

The implementation uses integer indices to store its geometry. This uses
minimal memory overhead, but it is less flexible than a corresponding `Ncube`.

Quickcheck is better at finding bad cases if irrelevant input is discarded. The
propositions now have an explicit dependency on quickcheck.

Method dispatch gets more complicated for types that partition more than one
domain.

There is a fat descriptive FIXME note in the source:

    Somehow this explicit usage of the `Rng` trait is required for
    the `.gen_range` calls, even though `Rng: Gen`. The compiler
    complains that the "source trait is private". Curiously, adding this
    import here fixes the same situation in the `cubemap` module as well.

It did fail a couple of times during a more extended debugging session, so I
chose to increase the error tolerance a little.

Implement more partitions and improve partition system

Increase tolerance of gravity tests to 10 %

Also they were not public before.

Expose geometry of UnitQuad and cubemap types