changed Lorenz example, etc

Author: chakravala

.appveyor.yml

@@ -2,9 +2,7 @@ environment:
   matrix:
   - julia_version: 1
   - julia_version: 1.6
-  - julia_version: 1.7
-  - julia_version: 1.8
-  - julia_version: 1.9
+  - julia_version: 1.10
   - julia_version: nightly
 
 platform:

Project.toml

@@ -1,23 +1,19 @@
 name = "Adapode"
 uuid = "0750cfb5-909a-49d7-927e-29b6595444bf"
 authors = ["Michael Reed"]
-version = "0.2.8"
+version = "0.2.9"
 
 [deps]
 Requires = "ae029012-a4dd-5104-9daa-d747884805df"
-DirectSum = "22fd7b30-a8c0-5bf2-aabe-97783860d07c"
 Grassmann = "4df31cd9-4c27-5bea-88d0-e6a7146666d8"
 TensorFields = "86e2b4fd-d9c8-44dc-a03f-e0a387f3b4e6"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
-AbstractTensors = "a8e43f4a-99b7-5565-8bf1-0165161caaea"
 
 [compat]
 julia = "1"
 Requires = "1"
-AbstractTensors = "0.7"
 TensorFields = "0.1"
-DirectSum = "0.8"
 Grassmann = "0.8"
 
 [extras]

README.md

@@ -17,11 +17,11 @@ This Julia project originally started as a FORTRAN 95 project called [adapode](h
 ```julia
 using Grassmann, Adapode, Makie
 x0 = Chain(10.0,10.0,10.0)
-Lorenz(x) = Chain(
-	10.0(x[2]-x[1]),
-	x[1]*(28.0-x[3])-x[2],
-	x[1]*x[2]-(8/3)*x[3])
-lines(odesolve(Lorenz,x0))
+Lorenz(σ,r,b) = x -> Chain(
+	σ*(x[2]-x[1]),
+	x[1]*(r-x[3])-x[2],
+	x[1]*x[2]-b*x[3])
+lines(odesolve(Lorenz(10.0,28.0,8/3),x0))
 ```
 Supported ODE solvers include:
 explicit Euler,

examples/chaos.jl

@@ -0,0 +1,47 @@
+
+
+using Grassmann, Adapode, Makie
+x0 = Chain(10.0,10.0,10.0)
+
+Lorenz(σ,r,b) = x -> Chain(
+	σ*(x[2]-x[1]),
+	x[1]*(r-x[3])-x[2],
+	x[1]*x[2]-b*x[3])
+lines(odesolve(Lorenz(10.0,28.0,8/3),Chain(10.0,10.0,10.0)))
+lines(odesolve(Lorenz(10.0,60.0,8/3),Chain(10.0,10.0,10.0)))
+
+DiskDynamo(a,b,c) = x -> Chain(
+    a*(x[2]-x[1]),
+    x[3]*x[1]-x[2],
+    b-x[1]*x[2]-c*x[3])
+lines(odesolve(DiskDynamo(14.625,1.0,5.0),Chain(10.0,10.0,10.0)))
+
+Rossler(a,b,c) = x -> Chain(
+    -(x[2]+x[3]),
+    x[1]+a*x[2],
+    b+x[3]*(x[1]-c))
+lines(odesolve(Rossler(1/5,1/5,2.4),x0))
+lines(odesolve(Rossler(1/5,1/5,3.5),x0))
+lines(odesolve(Rossler(1/5,1/5,4.0),x0))
+lines(odesolve(Rossler(1/5,1/5,4.23),x0))
+lines(odesolve(Rossler(1/5,1/5,4.3),x0))
+lines(odesolve(Rossler(1/5,1/5,5.0),x0))
+lines(odesolve(Rossler(1/5,1/5,5.7),x0))
+lines(odesolve(Rossler(0.0,0.0,12.0),x0))
+lines(odesolve(Rossler(0.0,0.0,25.0),x0))
+lines(odesolve(Rossler(0.343,1.82,9.75),x0))
+
+ChemicalKinetics(a1,a2,a3,a4,a5,k1,k2) = x -> Chain(
+    x[1]*(a1-k1*x[1]-x[3]-x[2])+k2*x[2]*x[2]+a3,
+    x[2]*(x[1]-k2*x[2]-a5)+a2,
+    x[3]*(a4-x[1]-k5*x[3])+a3)
+lines(odesolve(ChemicalKinetics(30.0,0.01,0.01,16.5,10.0,0.25,0.001,0.5),x0))
+
+Rossler4(a,b,c,d) = x -> Chain(
+    -(x[2]+x[3]),
+    x[1]+a*x[2]+x[4],
+    b+x[3]*x[1],
+    d*x[4]-c*x[3])
+lines(odesolve(Rossler4(1/4,3.0,0.5,0.05),x0))
+
+

src/Adapode.jl

@@ -18,12 +18,11 @@ module Adapode
 #  |___|___||_____||___._||   __||_____||_____||_____|
 #                         |__|
 
-using SparseArrays, LinearAlgebra
-using AbstractTensors, DirectSum, Grassmann, TensorFields, Requires
+using SparseArrays, LinearAlgebra, Grassmann, TensorFields, Requires
 import Grassmann: value, vector, valuetype, tangent, list
+import Grassmann: Values, Variables, FixedVector
+import Grassmann: Scalar, GradedVector, Bivector, Trivector
 import Base: @pure
-import AbstractTensors: Values, Variables, FixedVector
-import AbstractTensors: Scalar, GradedVector, Bivector, Trivector
 
 export Values, odesolve, odesolve2
 export initmesh, pdegrad
@@ -67,6 +66,7 @@ function weights(c,fx)
     return cfx
 end
 @pure shift(::Val{m},::Val{k}=Val(1)) where {m,k} = Values{m,Int}(list(k,m+k-1))
+#@pure shift(M::Val{m},i) where m = ((shift(M,Val{0}()).+i).%m).+1
 @pure shift(::Val{m},l::Val,i) where m = ((shift(l,Val(0)).+i).%m).+1
 function explicit(x,h,c,fx)
     l = length(c)
@@ -270,6 +270,22 @@ function odesolve2(f,x0,tmax=2π,tol=15,M::Val{m}=Val(1),B::Val{o}=Val(4)) where
     return x
 end
 
+function integrate(f::TensorField,x,tmax=2π,tol=15,M::Val{m}=Val(1),B::Val{o}=Val(4)) where {m,o}
+    x0,t = init(x),TimeStep(2.0^-tol)
+    if m == 0 # Improved Euler, Heun's Method
+        x = initsteps(x0,t,tmax,M)
+        for i ∈ 2:length(x)
+            @inbounds x[i] = heun(x[i-1],f,t.h)
+        end
+    elseif m == 3 # Multistep
+        x,fx = initsteps(x0,t,tmax,f,M,B)
+        for i ∈ o+1:length(x)
+            @inbounds x[i] = predictcorrect(x,f,fx,t,B)
+        end
+    end
+    return x
+end
+
 function timeloop!(x,t,tmax,::Val{m}=Val(1)) where m
     if t.e < t.emin
         t.h *= 2