update readme, added changelog

Author: martinjrobins

CHANGELOG

@@ -0,0 +1,33 @@
+#######################################
+#           Aboria 0.5                #
+#######################################
+
+Summary
+
+    This version has extensive changes to the backend iterators that are used to interact
+    with the neighbourhood search data structures, to fit in the new tree-based structures.
+    In particular, there is a new `child_iterator` that is used to iterate through children
+    of a node in a tree, a depth-first search iterator, and a query iterator specificly
+    for neighbour searches on a tree
+    
+    There are also large changes with the backend neighbourhood search functionality. Now 
+    a distance search can:
+        * be anisotropic, the distance measure is scaled independently in each dimension
+        * use any L-norm for a distance measure, L1, L2, L3, ...., Linf
+        * can handle periodic domains independently of the data structure
+        * can handle any radius, independently of how the data structure was initialized 
+          (see below)
+
+    Finally, the syntax for the `Aboria::Particles::init_neighbour_search` does not require
+    the user to enter in a cut-off radius, instead the user can enter in a number corresponding
+    to the average (for cell lists) or maximum (for trees) number of particles in each cell/bucket.
+
+    New search data structures! Finally have a kd-tree (courtesy of nannoflann 
+    - https://github.com/jlblancoc/nanoflann), and an octtree. These are used for the new 
+    fast multipole method and hierarchical matrix kernel operators.
+
+    New kernel operators - Aboria now has implementations of the black-box fast multipole
+    method, and the ability to store this as a H2 hierarchical matrix for repeated evaluations.
+    Please see documentation for more details. btw. The previous functionality termed "matrix-free"
+    operators has been renamed to "kernel operators" to factor in these changes.
+        

README.md

@@ -4,28 +4,34 @@
 [![AppVeyor](https://ci.appveyor.com/api/projects/status/6aimud6e8tvxfwgm?svg=true)](https://ci.appveyor.com/project/martinjrobins/aboria)
 -->
 
-Aboria implements an expressive Domain Specific Language (DSL) in C++ for 
+Aboria implements an Embedded Domain Specific Language (eDSL) in C++ for 
 specifying expressions over particles and their neighbours in N dimensional 
-space. The library is header-only and based on expression templates for 
-efficient and natural expression of mathematical expressions applied over the 
-particles.
-
-The particle data is contained in a STL compatible container. Each particle has 
-a position and user-defined data-package (for other variables such as velocity, 
-density etc) and is optionally embedded within a cuboidal spatial domain (for 
-neighbourhood searches) that can be periodic or not. Users can implement 
-standard C++ and STL algorithms directly on the particle data, or use the 
-expression template API to naturally form operations over the particle set.
-
-The motivation behind Aboria is to provide a useful library for implementing 
-particle-based numerical algorithms, for example Smoothed Particle Hydrodynamics 
-or Molecular/Langevin Dynamics.
+space, with the aim of providing a useful library for implementing 
+particle-based numerical algorithms, for example Molecular Dynamics, Smoothed 
+Particle Hydrodynamics or Radial Basis Functions. 
 
+Aboria provides:
+    * a STL compatible container class to store a particle set containing
+      a position and unique id for each particle, as well as any number of 
+      user-defined variables with arbitrary types.
+    * the ability to embed each particle set within a hypercube N-dimensional
+      domain with arbitrary periodicity
+    * flexible neighbourhood queries that return iterators, and can use any 
+      L-norm distance measure (L1 = Manhattan distance, L2 = Euclidean distance, 
+      ... , Linf = Chebyshev distance)
+    * an expression template API for forming non-linear operators over the 
+      particles. This can be used, for example, to implement interaction forces
+      in Molecular Dynamics.
+    * an API for forming linear kernel operators from C++ lambda functions, This
+      can be used, for example, to implement Radial Basis Function kernels. 
+      These can be wrapped as ![Eigen](eigen.tuxfamily.org) matrices in order to 
+      solve linear systems based on kernel operators.
+    
+    
 Aboria is distributed under a BSD 3-Clause License, see LICENCE for more 
-details.
-
-For documentation see the [Aboria 
+details. For documentation see the [Aboria 
 website](https://martinjrobins.github.io/Aboria). If you are interested in 
 contributing to Aboria, having trouble getting it working or just have a 
-question, send me an email at <[email protected]>.
+question, send me an email at <[email protected]> or create a
+GitHub issue or pull request.
 

doc/CMakeLists.txt

@@ -138,6 +138,7 @@ MathJax.Hub.Config({
     images/up.png
     images/down.png
     images/home.png
+    images/note.png
     css/boostbook.css
   )
 

doc/images/note.png

@@ -94,9 +94,6 @@ class H2Test: public CxxTest::TestSuite {
             TS_ASSERT_LESS_THAN(L2_h2/scale,1e-2);
         }
 
-        for (reference p: particles) {
-            get<target_h2>(p) = 0;
-        }
         t0 = Clock::now();
         auto h2_eigen = create_h2_operator<N>(particles,particles,
                                     kernel);

tests/h2.h

@@ -482,7 +482,7 @@ row particles.
         }
 
         /*
-         * create new h2 operator with new row particles
+         * create h2 operator with new row particles
          */
         auto K_h2 = create_h2_operator(K_h.get_first_kernel(),particles2);