A-B-M is @obiajulu's work: JuliaLang/ODE.jl#106
There is some work on stiff solvers: JuliaLang/ODE.jl#72 and @obiajulu is starting on RADAU, but nothing finished.
Anyway, have a look at the iterator work and see whether you like it. If so you could consider wrapping that instead of the old one. Also, wrapping outside solvers should be easy with that, and is planned.
tspan, see https://github.com/JuliaODE/ODE.jl/blob/dev/src/types.jl for our latest thoughts.
And is this the page that will have the most up to date API? https://github.com/JuliaODE/ODE.jl/blob/dev/doc/api.md
Sorry, docs are missing (above is outdated), but the code is starting to be reasonably documented. Looking at https://github.com/JuliaODE/ODE.jl/blob/dev/src/ODE.jl tells you the order of things.
I think I'm seeing it.
All of your functions are in-place?
they are
and there if you want to comment/ask questions we have a gitter chat room https://gitter.im/JuliaODE/ODE.jl
we keep it for backward compatibility
This is the way to call the iterators
ode = ODE.ExplicitODE(t0,y0,(t,y,dy)->dy[1]=y[1])
opts = Dict(:initstep=>0.1,
:tspan=>[0.,0.5,1.],
:points=>:specified,
:reltol=>1e-5,
:abstol=>1e-5)
stepper = ODE.RKStepperAdaptive{:rk45}
sol = ODE.solve(ode,stepper;opts...)
for (t,y) in sol # iterate over the solution
println((t,y))
end
println(collect(sol)) # get all the solution at once
I will be back in 10 min
I think I will wrap the
ODE.solve(ode,stepper;opts...) calls.
Just a heads up on what I'm doing.
Currently I have it set so that way you just do
solve(prob,tspan,alg=:algorithm)
There's a bunch of keyword args I already have.
I am going to setup inside my solve command a way for it to use conditional dependencies (a la Plots.jl or JuMP)
and then add your ODE.jl algorithms as options to choose.
Then I'm going to be doing the same with ODEInterface.jl.
I'll make a quick little test suite from these, but since I already have plot recipes down and such, you can see that's going to be quick.
In the meantime, since I see you have a lot of the ODE algorithms down, I won't be implementing many more.
I do have planned before the end of the summer though to do the Feagin's RK methods (especially the Order 14 one).
What benefits will your wrapper have to wrapping them directly?
Will it add dense output or something? (I think they have all of that jazz)
it would be a general interface for calling ODE solvers (implemented in ODE.jl directly or just wrapped like PETSc). This way people wouldn't have to create separate wrappers themselves. We would also take care of translating various options into their proper form effectively unifying keyword options.
But if that is not an option, you can also use it at some later stage.
I think I remember you're faculty in Germany, so you probably get super busy during the year?
If that's the case, I'll hold up on wrapping the other packages until nearing the end of summer to take stock on how far along you are with it.