luchr/odeinterface.jl

julia package providing an interface for ODE-solvers written in Fortran

ODEInterface

This julia module provides an interface to solvers for ordinary differential equations (ODEs) written in Fortran for solving initial value problems (IVP) of the form

x' = rhs(t,x),      x(t₀) = x₀

or (for solvers supporting a "mass matrix" M)

M⋅x' = rhs(t,x),    x(t₀) = x₀.

Additionally a boundary value solver (called bvpsol) is supported for boundary value problems (BVP) of the form

x' = rhs(t,x),      r = bc( xa, xb ) = 0

What does "Interface" mean?

This julia module does not contain code for solving initial value problems, but this module does contain code for interacting with compiled Fortran-solvers. That's the reason, why this module is not called ODESuite. See the requirements below how to get to the compiled Fortran-solvers.

What solvers are currently supported?

Currently the following Fortran-solvers, written by Prof. E. Hairer and Prof. G. Wanner, are supported:

• dopri5: explicit Runge-Kutta method of order 5(4) due to Dormand & Prince
• dop853: explicit Runge-Kutta method of order 8(5,3) due to Dormand & Prince
• odex: GBS extrapolation-algorithm based on the explicit midpoint rule
• radau5: implicit Runge-Kutta method (Radau IIA) of order 5
• radau: implicit Runge-Kutta method (Radau IIA) of variable order between 5 and 13
• seulex: extrapolation-algorithm based on the linear implicit Euler method
• rodas: Rosenbrock method of order 4(3) (with possibly singular mass matrix)

see Software page of Prof. Hairer.

Additionally the following Fortran-solvers from the SLATEC Common Mathematical Library are supported:

• ddeabm: Adams-Bashforth-Moulton Predictor-Corrector method (order between 1 and 12)
• ddebdf: Backward Differentiation Formula (orders between 1 and 5)

Also supported:

• bvpsol: a boundary value problem solver for highly nonlinear two point boundary value problems using either a local linear solver or a global sparse linear solver. Please note: The license for bvpsol only covers non commercial use, see License. Written by P. Deuflhard, G. Bader, L. Weimann, see CodeLib at ZIB.
• colnew: a multi-point boundary value problem solver for mixed order systems using collocation. Written by U. Ascher, G. Bader, see Colnew Homepage
• BVP_M-2: a boundary value problem solver for the numerical solution of boundary value ordinary differential equations with defect and global error control. Written by J. J. Boisvert, P.H. Muir and R. J. Spiteri, see BVP_M-2 Page

Description: Calling the Solvers

The following features of the IVP-solvers are supported by this ODEInterface:

• providing an output function (e.g. for dense output or for event location) to the solvers
• providing mass- and jacobi-matrices for the solvers (with support for banded matrices)
• all the solvers' parameters for fine-tuning them, see Options for Solvers and Option Overview
• support for problems with "special structure", see special structure

What are the requirements for this module

This module needs the compiled Fortran solvers as shared libraries (i.e. .so, .dylib or .dll files, respectively). There are three ways to get them:

• The package ODEInterface_jll.jl has precompiled solvers for different platforms. Julia 1.3 or newer is needed for this. This is the default behaviour for julia versions 1.3 or newer.
• The build-script of this module: It tries to use gfortran and compile the solver libraries. This is the default behaviour for julia versions less than 1.3.
• You compile the solvers yourself (perhaps with different options and/or a different compiler). In this case just call ODEInterface.help_solversupport for further informations (help topics) on how to compile the solvers and how to create shared libraries.

Please see the help for ODEInterface.loadODESolves how to ignore the precompiled ODEInterface_jll package and use the/your locally built libraries.

Further help

see ODEInterface.help_overview for an overview of some help topics.

Examples

• basic examples can be found in examples/BasicExamples
• more advanced examples can be found in examples/AdvancedExamples
• the Reentry Problem of the Apollo11 mission can be found in examples/ReentryOfApollo11

Contacting the author of this module

The author of this julia module is

 Dr. Christian Ludwig
 email: [email protected]
   (Faculty of Mathematics, Technische Universität München)

odeinterface.jl's Issues

AppVoyer Compatibility?

It seems ODEInterface is should work on Windows. Is there any way for it to build on AppVoyer? Right now I have tests which use ODEInterface disabled on AppVoyer since it needs to find a mingw-64 install.

Tag?

It would be good to have a tagged version with the JLLs.

LSODE

LSODE is an old popular stiff solver. Reference and blog post. Given that it has had quite a long history as one of the ODE solvers, it would be nice to have it available in Julia as well. It seems like it would fit best here given that this seems to be the core library which holds all of the C/Fortran codes.

Tests failing on MacOSX?

Sometime within the last week my MacOSX tests started failing due to this dependency, with an error during building:

INFO: Building ODEInterface
============================[ ERROR: ODEInterface ]=============================
LoadError: Currently only gfortran is supported.
while loading /Users/travis/.julia/v0.5/ODEInterface/deps/build.jl, in expression starting on line 157
================================================================================

The Travis script I am using is similar to yours, adding in there:

addons:
  apt:
    packages:
      - gfortran

for gfortran, which seems to no longer apply on MacOSX. This makes me think something changed on MacOSX Travis to change this. Do you mind re-running your tests to see if this is the case?

Add the common interface code to ODEInterface?

Hey,
I was wondering if you would like to include the code to plug into the JuliaDiffEq "common interface". This common interface is a type-based interface which makes all of the differential equations solvers have a common solver signature. The full discussion is here:

SciML/Roadmap#5

Since the discussion is long, let me give a quick summary. There is a problem type which defines the Cauchy problem to solve:

type ODEProblem{uType,tType,isinplace,F} <: AbstractODEProblem{uType,tType,isinplace,F}
  f::F
  u0::uType
  tspan::Vector{tType}
end

https://github.com/JuliaDiffEq/DiffEqBase.jl/blob/common_interface/src/problems.jl#L26

Each algorithm is a subtype of AbstractODEAlgorithm and thus the command solve(prob,alg;kwargs....) dispatches to the appropriate solvers from the appropriate packages. For example, I have the following preliminary code in OrdinaryDiffEq.jl which implements this interface over ODEInterface:

The Algorithm types (may need to be renamed due to the name clashes with the functions):
https://github.com/JuliaDiffEq/OrdinaryDiffEq.jl/blob/common_interface/src/algorithms.jl#L141

The solve dispatch
https://github.com/JuliaDiffEq/OrdinaryDiffEq.jl/blob/common_interface/src/solve/ode_solve.jl#L191

A user can then seamlessly call ODEInterface's algorithms from this interface, as seen in these tests:
https://github.com/JuliaDiffEq/OrdinaryDiffEq.jl/blob/common_interface/test/ode/ODEInterface_tests.jl

The tests show that even the common interface's keyword arguments will work, which is currently done by aliasing:
https://github.com/JuliaDiffEq/OrdinaryDiffEq.jl/blob/common_interface/src/solve/ode_constants.jl#L57
https://github.com/JuliaDiffEq/OrdinaryDiffEq.jl/blob/common_interface/src/solve/ode_solve.jl#L224

But if this code is in ODEInterface, it can more easily be tailored to get rid of this extra step.

This code needs to be removed from OrdinaryDiffEq.jl to get rid of the conditional dependency usage initialize_backend(:ODEInterface) (ODEInterface is not a full dependency because of the possibility of compilation issues).

What a user gets out of that is a solution object which acts very nicely:

sol[i] # Gets the ith value of u, the saved timeseries
sol.t[i] # Gets the timepoint of the ith save

A separate solution subtype ODEInterfaceSolution <: AbstractODESolution might be necessary to implement the interpolation part of the interface, which allows a user to:

sol(t) # Gets the interpolated solution at `t`

Thus without any prior knowledge of the solvers, users are able to easily and uniformly use advanced features like dense output from many different packages.

One benefit from joining the common interface is that there are plenty of tools which have been built or are being built on this interface. For example, DiffEqParamEstim.jl performs parameter estimation, and can use any of the backend ODE solver algorithms which are part of the common interface for the solving step. DiffEqDevTools.jl gives benchmarking which works on all algorithms in the common interface, and while the results show I've been able to beat the Fortran code in performance in nonstiff equations, that Radau solver is still one hell of an efficient stiff solving method:

https://github.com/JuliaDiffEq/DiffEqBenchmarks.jl

The amount of tools which are part of this are seemingly endless, and it would be nice for ODEInterface to join the group in a more formal way rather than being tagged onto OrdinaryDiffEq.jl as a conditional dependency. Thanks!

bvps with singularities at both ends

As far as I see, bvpm2 only handles singularities at the start, is there a way to handle also the case where you have singularities at both sides?

Migrate to JuliaDiffEq?

We are trying to have one organization to coordinate APIs for the differential equations packages in Julia. I think ODEInterface would be a good fit in this organization. I think this package would be a good place to wrap the other popular Fortran solvers (ROCK, LSODE, etc.) and coordinate those efforts along with other solvers.

Using ODEInterface in Juliabox(.com)

If you get the error

Error: Error building `ODEInterface`: 
[ Info: Using JuliaBox Pkg Manager
ERROR: LoadError: ArgumentError: Package REPL not found in current path:
- Run `import Pkg; Pkg.add("REPL")` to install the REPL package.

simply start a terminal New -> Terminal and type the following line:

julia -e 'using Pkg; Pkg.add("ODEInterface");Pkg.build("ODEInterface");'

This should download, install and build the package successfully.

After this you can use it in notebooks.

Windows Build

Hey, I can't seem to get the Windows build to work. I installed mingw-w64 and in the terminal when I run gfortran it shows that it's in my path. However, when I run Pkg.build("ODEInterface") I get an error LoadError: Currently only gfortran is supported.

Error compiling with GNU Fortran (Rev3, Built by MSYS2 project) 10.1.0

When building I get the following error:

Error: Rank mismatch in argument 'yold' at (1) (rank-1 and scalar)
C:\Users\***\.julia\packages\ODEInterface\Dz5xs\src\bvpsol.f:4853:40:

 4853 |          CALL BLDFSC ('ACCEPTED', Y, N, DUMMY, YWGT, YMAX, TOL, ONE)
      |                                        1
Error: Rank mismatch in argument 'yold' at (1) (rank-1 and scalar)

when calling ODEInterface.loadODESolvers(), the following are not compiled correctly:
colnew_i32, bvpsol, bvp_m_proxy, colnew, bvpsol_i32

If I modify the build.jl build_bvpsol function to include the flag "-std=legacy", the build runs withouth errors.

function build_bvpsol(path::AbstractString)
  options = Dict(
    "add_flags_i64" => ["-w", "-std=legacy"],
    "add_flags_i32" => ["-w", "-std=legacy"],
  )
  compile_gfortran(path,"bvpsol", options)
  compile_gfortran(path,"linalg_bvpsol")
  compile_gfortran(path,"zibconst")
  compile_gfortran(path,"ma28_bvpsol")
  link_gfortran(path,
    ["bvpsol","linalg_bvpsol","zibconst","ma28_bvpsol"])
  println("\n\n!!! bvpsol: only non commercial use !!!")
  println("Please note: bvpsol's license only covers non commercial use!")
  println("see using ODEInterface; help_bvpsol_license() for the complete")
  println("license text.")
  return nothing
end

Now, when calling ODEInterface.loadODESolvers(), all seem to be ok except 'bvp_m_proxy'. The dll is generated in src but for some reason it is not found:

ODEInterface.SolverDLinfo("bvp_m_proxy", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"bvp_m_proxy\", \"BVP_M_PROXY\", \"Bvp_m_proxy\"] in libpaths or in [\"C:\\\\Users\\\\***\\\\.julia\\\\packages\\\\ODEInterface\\\\Dz5xs\\\\src\"]"))

Julia 1.5.0
ODEInterface v0.4.7
GNU Fortran (Rev3, Built by MSYS2 project) 10.1.0
Windows 10

Solve Boundary Value DAEs w/ COLDAE

Hi and thank you for this package!
Is there a change you can extend it to solve boundary value DAEs w/ COLDAE?

Build error

Just updated my Julia packages with Pkg.update() and get the following build error:

.julia/v0.6/ODEInterface/src/colnew.f:846:34:
      1          W, V, RHS, DUMMY, INTEGS, IPVTG, IPVTW, RNORM, 0,
                                  1
Error: Actual argument contains too few elements for dummy argument ‘integs’ (1/3) at (1)

ODEX-P

It would be cool to have the parallel extrapolation implementation from this paper, denoted as ODEX-P, in this library. It just takes a simple modification of the ODEX code (see page 19).

Wrap ROCK/RKC solvers?

You can find ROCK2 and ROCK4 from Hairer's site as well as mildly-stiff integrators. I think this would be a good home for them.

(also brainstorming, would you include the DDE codes RETARD and RADAR5 from that same page?)

loadODESolvers() not working

I am using Windows 10 64 bit.
I performed the following steps in Juno in Julia REPL:
] add ODEInterface
build ODEInterface
loadODESolvers()

The ODEInterface package is added and built as normal however the loadODESolver() command throws an “UndefVarError”.
I have installed and added mingw64 to my path so cannot understand what is going wrong. And I cannot use any of the ODEInterface functions like radau in my code. Please help.
Thanks

Have BinaryBuilder recipes to get these into Yggdrasil

It would be nice to have BB recipes to get the fortran libs into Yggdrasil. I am happy to help.

In-place functions

Is there any way to use in-place functions with the wrapped codes, i.e. f(du,u,u)? Or do they not support that? I found my implementations in DifferentialEquations.jl were able to dominate the dopri5 code, and I think this may be one of the reasons.

Solvers not found

I run and see:

julia> using ODEInterface

julia> loadODESolvers()
ERROR: UndefVarError: loadODESolvers not defined
Stacktrace:
 [1] top-level scope at none:0

julia> ODEInterface.loadODESolvers()
Dict{AbstractString,ODEInterface.SolverDLinfo} with 23 entries:
  "colnew_i32"  => SolverDLinfo("colnew_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"colnew_i32\", \"COLNEW_I32\", \"Colnew_i32\"] in libpaths or in [\"C:\\\\Users\\\\accou\\\\.julia\\\\dev\\\\ODEInterface\\\\src\\\\\"]"))
  "radau_i32"   => SolverDLinfo("radau_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"radau_i32\", \"RADAU_I32\", \"Radau_i32\"] in libpaths or in [\"C:\\\\Users\\\\accou\\\\.julia\\\\dev\\\\ODEInterface\\\\src\\\\\"]"))
  "bvpsol"      => SolverDLinfo("bvpsol", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"bvpsol\", \"BVPSOL\", \"Bvpsol\"] in libpaths or in [\"C:\\\\Users\\\\accou\\\\.julia\\\\dev\\\\ODEInterface\\\\src\\\\\"]"))
  "seulex"      => SolverDLinfo("seulex", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"seulex\", \"SEULEX\", \"Seulex\"] in libpaths or in [\"C:\\\\Users\\\\accou\\\\.julia\\\\dev\\\\ODEInterface\\\\src\\\\\"]"))
  "odex_i32"    => SolverDLinfo("odex_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"odex_i32\", \"ODEX_I32\", \"Odex_i32\"] in libpaths or in [\"C:\\\\Users\\\\accou\\\\.julia\\\\dev\\\\ODEInterface\\\\src\\\\\"]"))
  "seulex_i32"  => SolverDLinfo("seulex_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"seulex_i32\", \"SEULEX_I32\", \"Seulex_i32\"] in libpaths or in [\"C:\\\\Users\\\\accou\\\\.julia\\\\dev\\\\ODEInterface\\\\src\\\\\"]"))
  "bvp_m_proxy" => SolverDLinfo("bvp_m_proxy", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"bvp_m_proxy\", \"BVP_M_PROXY\", \"Bvp_m_proxy\"] in libpaths or in [\"C:\\\\Users\\\\accou\\\\.julia\\\\dev\\\\ODEInterface\\\\src\\\\\"]"))
  "dopri5_i32"  => SolverDLinfo("dopri5_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"dopri5_i32\", \"DOPRI5_I32\", \"Dopri5_i32\"] in libpaths or in [\"C:\\\\Users\\\\accou\\\\.julia\\\\dev\\\\ODEInterface\\\\src\\\\\"]"))
  "radau5_i32"  => SolverDLinfo("radau5_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"radau5_i32\", \"RADAU5_I32\", \"Radau5_i32\"] in libpaths or in [\"C:\\\\Users\\\\accou\\\\.julia\\\\dev\\\\ODEInterface\\\\src\\\\\"]"))
  ⋮             => ⋮

However, I can see that the files do indeed exist:

C:\Users\accou\.julia\dev\ODEInterface\src>dir
 Volume in drive C is OS
 Volume Serial Number is A084-D380

 Directory of C:\Users\accou\.julia\dev\ODEInterface\src

02/25/2019  06:16 PM    <DIR>          .
02/25/2019  06:16 PM    <DIR>          ..
02/25/2019  06:10 PM            13,480 Banded.jl
02/25/2019  06:10 PM             4,386 Base.jl
02/25/2019  06:10 PM            64,788 Bvpm2.jl
02/25/2019  06:11 PM           264,179 bvpsol.dll
02/25/2019  06:10 PM           189,993 bvpsol.f
02/25/2019  06:10 PM            25,886 Bvpsol.jl
02/25/2019  06:11 PM           157,821 bvpsol_i32.dll
02/25/2019  06:10 PM           114,289 bvp_la-2.f
02/25/2019  06:10 PM           260,036 bvp_m-2.f90
02/25/2019  06:10 PM             2,836 bvp_m.mod
02/25/2019  06:11 PM           358,516 bvp_m_proxy.dll
02/25/2019  06:10 PM            67,744 bvp_m_proxy.f90
02/25/2019  06:10 PM             3,287 bvp_m_proxy.mod
02/25/2019  06:10 PM             5,276 Call.jl
02/25/2019  06:11 PM           121,968 colnew.dll
02/25/2019  06:10 PM           132,088 colnew.f
02/25/2019  06:10 PM            45,015 Colnew.jl
02/25/2019  06:11 PM            82,834 colnew_i32.dll
02/25/2019  06:10 PM             4,548 compile.sh
02/25/2019  06:10 PM            56,025 dc_lapack.f
02/25/2019  06:11 PM           126,576 ddeabm.dll
02/25/2019  06:10 PM            33,027 ddeabm.f
02/25/2019  06:11 PM            92,220 ddeabm_i32.dll
02/25/2019  06:11 PM           130,672 ddebdf.dll
02/25/2019  06:10 PM            45,701 ddebdf.f
02/25/2019  06:11 PM            95,292 ddebdf_i32.dll
02/25/2019  06:10 PM            18,773 Deabm.jl
02/25/2019  06:10 PM            22,484 Debdf.jl
02/25/2019  06:10 PM             8,140 DLSolvers.jl
02/25/2019  06:11 PM            54,427 dop853.dll
02/25/2019  06:10 PM            34,377 dop853.f
02/25/2019  06:10 PM            15,782 Dop853.jl
02/25/2019  06:11 PM            46,887 dop853_i32.dll
02/25/2019  06:10 PM            10,100 Dopri.jl
02/25/2019  06:11 PM            48,813 dopri5.dll
02/25/2019  06:10 PM            23,960 dopri5.f
02/25/2019  06:10 PM            15,774 Dopri5.jl
02/25/2019  06:11 PM            41,785 dopri5_i32.dll
02/25/2019  06:10 PM             3,226 Error.jl
02/25/2019  06:10 PM            19,620 Help.jl
02/25/2019  06:10 PM            16,493 HWcommon.jl
02/25/2019  06:10 PM           123,082 lapack.f
02/25/2019  06:10 PM           113,669 lapackc.f
02/25/2019  06:10 PM            13,277 linalg_bvpsol.f
02/25/2019  06:10 PM           119,263 ma28_bvpsol.f
02/25/2019  06:10 PM            20,427 ODEInterface.jl
02/25/2019  06:11 PM            59,982 odex.dll
02/25/2019  06:10 PM            31,274 odex.f
02/25/2019  06:10 PM            29,654 Odex.jl
02/25/2019  06:11 PM            48,186 odex_i32.dll
02/25/2019  06:10 PM             4,448 Options.jl
02/25/2019  06:11 PM           310,578 radau.dll
02/25/2019  06:10 PM            70,956 radau.f
02/25/2019  06:10 PM            54,394 Radau.jl
02/25/2019  06:11 PM           277,208 radau5.dll
02/25/2019  06:10 PM            42,134 radau5.f
02/25/2019  06:11 PM           176,324 radau5_i32.dll
02/25/2019  06:11 PM           200,990 radau_i32.dll
02/25/2019  06:11 PM           274,986 rodas.dll
02/25/2019  06:10 PM            38,027 rodas.f
02/25/2019  06:10 PM            34,486 Rodas.jl
02/25/2019  06:11 PM           176,170 rodas_i32.dll
02/25/2019  06:11 PM           285,503 seulex.dll
02/25/2019  06:10 PM            43,723 seulex.f
02/25/2019  06:10 PM            38,444 Seulex.jl
02/25/2019  06:11 PM           180,011 seulex_i32.dll
02/25/2019  06:10 PM           249,824 slatec.f
02/25/2019  06:10 PM             7,405 SLATECcommon.jl
02/25/2019  06:10 PM             4,623 SoloutEval.jl
02/25/2019  06:10 PM               681 zibconst.f
              70 File(s)      5,908,853 bytes
               2 Dir(s)  155,570,290,688 bytes free

Built binaries are not found

The binaries seem to get built but then aren't found, causing test failures.

julia> using ODEInterface

julia> ODEInterface.loadODESolvers()

Dict{AbstractString,ODEInterface.SolverDLinfo} with 23 entries:
  "colnew_i32"  => SolverDLinfo("colnew_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"colnew_i32\", \"COLNEW_I32\", \"Colnew_i32\"] in libpaths or in [\"C:\\\\Users\\\\accou\\\\.ju…  "radau_i32"   => SolverDLinfo("radau_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"radau_i32\", \"RADAU_I32\", \"Radau_i32\"] in libpaths or in [\"C:\\\\Users\\\\accou\\\\.julia\…  "bvpsol"      => SolverDLinfo("bvpsol", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"bvpsol\", \"BVPSOL\", \"Bvpsol\"] in libpaths or in [\"C:\\\\Users\\\\accou\\\\.julia\\\\dev\\\\OD…  "seulex"      => SolverDLinfo("seulex", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"seulex\", \"SEULEX\", \"Seulex\"] in libpaths or in [\"C:\\\\Users\\\\accou\\\\.julia\\\\dev\\\\OD…  "odex_i32"    => SolverDLinfo("odex_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"odex_i32\", \"ODEX_I32\", \"Odex_i32\"] in libpaths or in [\"C:\\\\Users\\\\accou\\\\.julia\\\\d…  "seulex_i32"  => SolverDLinfo("seulex_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"seulex_i32\", \"SEULEX_I32\", \"Seulex_i32\"] in libpaths or in [\"C:\\\\Users\\\\accou\\\\.ju…  "bvp_m_proxy" => SolverDLinfo("bvp_m_proxy", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"bvp_m_proxy\", \"BVP_M_PROXY\", \"Bvp_m_proxy\"] in libpaths or in [\"C:\\\\Users\\\\accou\\\…  "dopri5_i32"  => SolverDLinfo("dopri5_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"dopri5_i32\", \"DOPRI5_I32\", \"Dopri5_i32\"] in libpaths or in [\"C:\\\\Users\\\\accou\\\\.ju…  "radau5_i32"  => SolverDLinfo("radau5_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"radau5_i32\", \"RADAU5_I32\", \"Radau5_i32\"] in libpaths or in [\"C:\\\\Users\\\\accou\\\\.ju…  "ddeabm_i32"  => SolverDLinfo("ddeabm_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"ddeabm_i32\", \"DDEABM_I32\", \"Ddeabm_i32\"] in libpaths or in [\"C:\\\\Users\\\\accou\\\\.ju…  "colnew"      => SolverDLinfo("colnew", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"colnew\", \"COLNEW\", \"Colnew\"] in libpaths or in [\"C:\\\\Users\\\\accou\\\\.julia\\\\dev\\\\OD…  "rodas_i32"   => SolverDLinfo("rodas_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"rodas_i32\", \"RODAS_I32\", \"Rodas_i32\"] in libpaths or in [\"C:\\\\Users\\\\accou\\\\.julia\…  ⋮             => ⋮

julia> println(readdir())
["Banded.jl", "Base.jl", "Bvpm2.jl", "bvpsol.dll", "bvpsol.f", "Bvpsol.jl", "bvpsol_i32.dll", "bvp_la-2.f", "bvp_m-2.f90", "bvp_m_proxy.dll", "bvp_m_proxy.f90", "Call.jl", "colnew.dll", "colnew.f", "Colnew.jl", "colnew_i32.dll", "compile.sh", "dc_lapack.f", "ddeabm.dll", "ddeabm.f", "ddeabm_i32.dll", "ddebdf.dll", "ddebdf.f", "ddebdf_i32.dll", "Deabm.jl", "Debdf.jl", "DLSolvers.jl", "dop853.dll", "dop853.f", "Dop853.jl", "dop853_i32.dll", "Dopri.jl", "dopri5.dll", "dopri5.f", "Dopri5.jl", "dopri5_i32.dll", "Error.jl", "Help.jl", "HWcommon.jl", "lapack.f", "lapackc.f", "linalg_bvpsol.f", "ma28_bvpsol.f", "ODEInterface.jl", "odex.dll", "odex.f", "Odex.jl", 
"odex_i32.dll", "Options.jl", "radau.dll", "radau.f", "Radau.jl", "radau5.dll", "radau5.f", "radau5_i32.dll", "radau_i32.dll", "rodas.dll", "rodas.f", "Rodas.jl", "rodas_i32.dll", "seulex.dll", "seulex.f", "Seulex.jl", "seulex_i32.dll", "slatec.f", "SLATECcommon.jl", "SoloutEval.jl", "zibconst.f"]

julia> pwd()
"C:\\Users\\accou\\.julia\\dev\\ODEInterface\\src"

Cannot use any of the methods in my code.

I'm using Windows 64-bit and I can't get any of the methods in this package to work. I usually work in notebooks but below is a transcript from my terminal so the issues are clear:

               _
   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.3.1 (2019-12-30)
 _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release
|__/                   |

julia> using DifferentialEquations
[ Info: Precompiling DifferentialEquations [0c46a032-eb83-5123-abaf-570d42b7fbaa]

julia> using ODEInterface

julia> @ODEInterface.import_huge

julia> loadODEsolvers()
ERROR: UndefVarError: loadODEsolvers not defined
Stacktrace:
 [1] top-level scope at REPL[4]:1

julia> loadODESolvers()
Dict{AbstractString,ODEInterface.SolverDLinfo} with 23 entries:
  "colnew_i32"  => SolverDLinfo("colnew_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"colnew_i32\", \"COLNEW_I32\", \"Colnew_i32\"]…
  "radau_i32"   => SolverDLinfo("radau_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"radau_i32\", \"RADAU_I32\", \"Radau_i32\"] in …
  "bvpsol"      => SolverDLinfo("bvpsol", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"bvpsol\", \"BVPSOL\", \"Bvpsol\"] in libpaths or …
  "seulex"      => SolverDLinfo("seulex", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"seulex\", \"SEULEX\", \"Seulex\"] in libpaths or …
  "odex_i32"    => SolverDLinfo("odex_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"odex_i32\", \"ODEX_I32\", \"Odex_i32\"] in libp…
  "seulex_i32"  => SolverDLinfo("seulex_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"seulex_i32\", \"SEULEX_I32\", \"Seulex_i32\"]…
  "bvp_m_proxy" => SolverDLinfo("bvp_m_proxy", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"bvp_m_proxy\", \"BVP_M_PROXY\", \"Bvp_m_prox…
  "dopri5_i32"  => SolverDLinfo("dopri5_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"dopri5_i32\", \"DOPRI5_I32\", \"Dopri5_i32\"]…
  "radau5_i32"  => SolverDLinfo("radau5_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"radau5_i32\", \"RADAU5_I32\", \"Radau5_i32\"]…
  "ddeabm_i32"  => SolverDLinfo("ddeabm_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"ddeabm_i32\", \"DDEABM_I32\", \"Ddeabm_i32\"]…
  "colnew"      => SolverDLinfo("colnew", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"colnew\", \"COLNEW\", \"Colnew\"] in libpaths or …
  "rodas_i32"   => SolverDLinfo("rodas_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"rodas_i32\", \"RODAS_I32\", \"Rodas_i32\"] in …
  "ddebdf_i32"  => SolverDLinfo("ddebdf_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"ddebdf_i32\", \"DDEBDF_I32\", \"Ddebdf_i32\"]…
  "dop853_i32"  => SolverDLinfo("dop853_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"dop853_i32\", \"DOP853_I32\", \"Dop853_i32\"]…
  "radau"       => SolverDLinfo("radau", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"radau\", \"RADAU\", \"Radau\"] in libpaths or in […
  "rodas"       => SolverDLinfo("rodas", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"rodas\", \"RODAS\", \"Rodas\"] in libpaths or in […
  "ddeabm"      => SolverDLinfo("ddeabm", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"ddeabm\", \"DDEABM\", \"Ddeabm\"] in libpaths or …
  "dop853"      => SolverDLinfo("dop853", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"dop853\", \"DOP853\", \"Dop853\"] in libpaths or …
  "ddebdf"      => SolverDLinfo("ddebdf", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"ddebdf\", \"DDEBDF\", \"Ddebdf\"] in libpaths or …
  "dopri5"      => SolverDLinfo("dopri5", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"dopri5\", \"DOPRI5\", \"Dopri5\"] in libpaths or …
  "odex"        => SolverDLinfo("odex", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"odex\", \"ODEX\", \"Odex\"] in libpaths or in [\"C:…
  "radau5"      => SolverDLinfo("radau5", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"radau5\", \"RADAU5\", \"Radau5\"] in libpaths or …
  "bvpsol_i32"  => SolverDLinfo("bvpsol_i32", "", Ptr{Nothing} @0x0000000000000000, (), ErrorException("Cannot find one of [\"bvpsol_i32\", \"BVPSOL_I32\", \"Bvpsol_i32\"]…

julia> function test(du,u,p,t)
       du[1]=u[1]
       end
test (generic function with 1 method)

julia> prob_test=ODEProblem(test,[1.0],(0.0,10.0))
ODEProblem with uType Array{Float64,1} and tType Float64. In-place: true
timespan: (0.0, 10.0)
u0: [1.0]

julia> sol=solve(prob_test,alg=radau())
ERROR: MethodError: no method matching radau()
Closest candidates are:
  radau(::Any, ::Real, ::Real, ::Array{T,1} where T, ::ODEInterface.AbstractOptionsODE) at C:\Users\13-AD008LA\.julia\packages\ODEInterface\lvq2F\src\Radau.jl:744
Stacktrace:
 [1] top-level scope at REPL[8]:1





If I try it in the notebook the error message is "Cannot find method(s) for radau! I've tried to loadODESolvers(), but it didn't work. Please check ODEInterface.help_solversupport() and call loadODESolvers and check also this output. For further information see also ODEInterface.help_install."

odesolver in BVPSOL

For the DiffEq wrapper of BVPSOL, I am hoping that we can allow any common interface method for the odesolver in BVPSOL. How exactly would I set that up? More specifically, what is it looking for in the odesolver argument? A function with a specific signature?

Add RODAS

It seems that the only ODE solvers from Hairer's set are the RODAS methods (and the deprecated ROS4, but that's probably not necessary). Is there any fundamental limitation that caused this that makes it different than the other solvers? Or is it just about finding the time to wrap it?

Can’t build ODEInterface on MacOS, “ld: library not found for -ldylib1.o”

I’m trying to use ODEInterface and ODEInterfaceDiffEq but encountered the following problem. I’m not sure what the issue is or how to resolve it? I am using Julia 1.0.3 on macOS Mojave 10.14.6. I have xcode and command line tools installed.

I also have gfortran from Macports installed, which gives me a different error:

How do I resolve these issues?