Overhaul DynamicalSystem, PR #24 from JuliaDynamics/dynamicalsystem

 Create something like DiscreteFast or whatever, that uses the existing minimal implementation. This will be used by default if the user gives eom, state instead of DiscreteProblem.
Auxilary functions, like e.g. set_parameters!.
trajectory. We ditch both evolve and evolve!.
Clearing up files (atm it is on NEW files to allow others to review easier)
Reform all of famous_systems.jl
Write proper documentation strings everywhere
Make parallel_evolver.
Remove DiffEqCallbacks dependency by making henon "not energy conserving" (and comment out the code for later use). This will only be implemented when #4 is solved.
Write up new tests (almost done).
Replace / reform old tests
Update the rest files of the library for the new definitions.
Make sure all tests pass AND THEN GGWP

Author: Datseris

CHANGELOG.md

@@ -1,14 +1,24 @@
 # v0.6
 ## Massively Breaking
-* Complete overhaul of Discrete Systems: all systems are now one, there is
-  no longer `DDS` and `BigDDS`. Everything is `DDS`!
+* Complete overhaul of all of DynamicalSystems. More details
+  are in the official documentation (because I would had to write 10 pages of changelog
+  otherwise). The constructors also changed signature.
+* All `DynamicalSystem`s are now  *immutable* and contain a problem,
+  a jacobian and a jacobian matrix.
+* Advantage of Multiple dispatch is taken to distinguish between in-place,
+  out of place, continuous, discrete, heaven, hell, whatever.
+* All internals use `integrator` and `step!`.
 * `variational_integrator` renamed to `tangent_integrator`.
-* `DDS` is made up of 2 fundamental parts: a DiscreteProblem and a
-  TangentEvolver.
+
 ## Non-breaking
 * Massive performance boost of up to 8x in system evolution of continuous systems.
-* `ParallelEvolver`
-* `TangentEvolver`
+* increased the interaction between DiffEq and DynamicalSystems.
+* A dedicated integrator for discrete systems that is super fast is now employed
+  by default. It follows the same high level DiffEq interface but the implementation
+  is totally internal.
+* Out-of-place continuous systems are allowed. All famous systems are actually
+  out of place now.
+* `parallel_integrator` added.
 
 # v0.5.0
 

REQUIRE

@@ -1,7 +1,6 @@
 julia 0.6
-OrdinaryDiffEq 3.0.1
-DiffEqBase 3.0.3
-DiffEqCallbacks 1.0.0
+OrdinaryDiffEq 3.1
+DiffEqBase 3.5
 ForwardDiff 0.5
 Requires 0.4.3
 StaticArrays 0.5.0

benchmarks/integrator_stepping.jl

@@ -0,0 +1,49 @@
+using DynamicalSystemsBase
+using Base.Test, StaticArrays
+using DynamicalSystemsBase: CDS, DDS
+using DynamicalSystemsBase.Systems: hoop, hoop_jac, hiip, hiip_jac
+using DynamicalSystemsBase.Systems: loop, loop_jac, liip, liip_jac
+using BenchmarkTools
+
+u0 = [0, 10.0, 0]
+p = [10, 28, 8/3]
+u0h = zeros(2)
+ph = [1.4, 0.3]
+
+FUNCTIONS = [liip, liip_jac, loop, loop_jac, hiip, hiip_jac, hoop, hoop_jac]
+INITCOD = [u0, u0h]
+PARAMS = [p, ph]
+
+for i in 1:8
+    println("Time to create & step! integrators, combination $i")
+    sysindx = i < 5 ? 1 : 2
+    if i < 5
+        if isodd(i)
+            ds = CDS(FUNCTIONS[i], INITCOD[sysindx], PARAMS[sysindx])
+        else
+            ds = CDS(FUNCTIONS[i-1], INITCOD[sysindx], PARAMS[sysindx], FUNCTIONS[i])
+        end
+    else
+        if isodd(i)
+            ds = DDS(FUNCTIONS[i], INITCOD[sysindx], PARAMS[sysindx])
+        else
+            ds = DDS(FUNCTIONS[i-1], INITCOD[sysindx], PARAMS[sysindx], FUNCTIONS[i])
+        end
+    end
+
+    integ = integrator(ds)
+    println("normal")
+    @time integ = integrator(ds)
+    step!(integ)
+    @time step!(integ)
+    te = tangent_integrator(ds, orthonormal(3,3))
+    println("tangent")
+    @time te = tangent_integrator(ds, orthonormal(3,3))
+    step!(te); step!(te)
+    @time step!(te)
+    te = parallel_integrator(ds, [INITCOD[sysindx], INITCOD[sysindx]])
+    println("parallel")
+    @time te = parallel_integrator(ds, [INITCOD[sysindx], INITCOD[sysindx]])
+    step!(te); step!(te)
+    @time step!(te)
+end

benchmarks/system_creation.jl

@@ -0,0 +1,51 @@
+using DynamicalSystemsBase
+using Base.Test, StaticArrays
+using DynamicalSystemsBase: CDS, DDS
+using DynamicalSystemsBase.Systems: hoop, hoop_jac, hiip, hiip_jac
+using DynamicalSystemsBase.Systems: loop, loop_jac, liip, liip_jac
+
+u0 = [0, 10.0, 0]
+p = [10, 28, 8/3]
+u0h = zeros(2)
+ph = [1.4, 0.3]
+
+FUNCTIONS = [liip, liip_jac, loop, loop_jac, hiip, hiip_jac, hoop, hoop_jac]
+INITCOD = [u0, u0h]
+PARAMS = [p, ph]
+
+#######################################################################################
+#                                      TIMINGS                                        #
+#######################################################################################
+println("\nStarting timings (using @time)..")
+
+println("\nAutodiff CDS (create/jacobian):")
+println("IIP")
+@time lip = CDS(liip, u0, p)
+jacobian(lip); @time jacobian(lip)
+println("OOP")
+@time lop = CDS(loop, u0, p)
+jacobian(lop); @time jacobian(lop)
+
+println("\n CDS (create/jacobian):")
+println("IIP")
+@time lipjac = CDS(liip, u0, p, liip_jac)
+jacobian(lipjac); @time jacobian(lipjac)
+println("OOP")
+@time lopjac = CDS(loop, u0, p, loop_jac)
+jacobian(lopjac); @time jacobian(lopjac)
+
+println("\nAutodiff DDS (create/jacobian):")
+println("IIP")
+@time hip = DDS(hiip, u0h, ph)
+jacobian(hip); @time jacobian(hip)
+println("OOP")
+@time hop = DDS(hoop, u0h, ph)
+jacobian(hop); @time jacobian(hop)
+
+println("\nDDS (create/jacobian):")
+println("IIP")
+@time hipjac = DDS(hiip, u0h, ph, hiip_jac)
+jacobian(hipjac); @time jacobian(hipjac)
+println("OOP")
+@time hopjac = DDS(hoop, u0h, ph, hoop_jac)
+jacobian(hopjac); @time jacobian(hopjac)

src/DynamicalSystemsBase.jl

@@ -10,9 +10,12 @@ include("dataset.jl")
 include("reconstruction.jl")
 include("various.jl")
 
-include("discrete.jl")
-include("continuous.jl")
-include("famous_systems.jl")
+include("dynamicalsystem/dynamicalsystem.jl")
+include("dynamicalsystem/discrete.jl")
+include("dynamicalsystem/continuous.jl")
+include("dynamicalsystem/famous_systems.jl")
+
+include("deprecations.jl")
 
 export Systems