The solution is to use FunctionWrappers.jl which provides a high
interface for C function pointers.

All tests passed.

update_state functions but performance gets worst.
With bench/pkg/abstract_arrays.jl i've highligthed each time a function
is in a collection performance gets worst.

models. It's a better semantic and improve performance as well as
readability of the code. All the tests passes (except the remark in the
last commit).

call of isabsorbing() during the simulation.

Now the package is a bit more efficient than DiffEqJump.jl with the
Catalyst.jl interface which is encouraging, see bench/pkg/catalyst.jl.

slight improvement in allocation and time in benchmark but too small.

Add several convenient methods for parameters of model.

Next step: implementation of simulate with resize!.

order to replace vcat by push!.

The benchmarks are at least equal, and better when the buffer size is
small. However, no significative difference of performance with adequate
buffer size.

My opinion the gain can be seen when simulations are going to be very
long with more complicated models than we have implemented for now.

All tests passed.

Major fix of type unstabilities which improved performances.
For now on, we observe for pygmalion benchmarks:
+2x speed simulation compared to simulation of models.
100x speed in terms of reading values (no allocations).

Add of bench for @view macro.

Implementation of the lp distance for trajectories.
Add of unit tests for lp distance.

previously loaded model). The package warns when this happen.

Several benchmarks for the data structure. Now we chose the row buffer
method according to results (mainly because the trajectory access with
far way faster, but strangly not that much differences in other cases).

- Add of benchmark scripts that compares perf wrt pygmalion.
=> As expected it is bad in terms of reading cost (because of row by row
matrix read) but it is also not good in terms of simulation cost.
hcat seems to perform badly, should investigate.