A simple domain-specific language (DSL) for defining differential equations for use in scientific machine learning (SciML) and other applications
Home Page: https://docs.sciml.ai/ParameterizedFunctions/stable/
License: Other
![dependabot[bot] avatar](https://avatars.githubusercontent.com/in/29110?v=4 "dependabot[bot]")
![femtocleaner[bot] avatar](https://avatars.githubusercontent.com/in/4123?v=4 "femtocleaner[bot]")
![github-actions[bot] avatar](https://avatars.githubusercontent.com/in/15368?v=4 "github-actions[bot]")
Hi there,
ParameterizedFunction.jl does not currently work in conjunction with differential algebraic equations using DAEProblem from DifferentialEquations.jl.
Please could we make this possible?
(this was already mentioned in #5)
Thanks,
Graham
This issue is used to trigger TagBot; feel free to unsubscribe.
If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.
If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!
For use with KNet and TensorFlow, there's a new form f(:Val{:vec},t,u) and f(:Val{:vec},t,u,du) which output the vectorized forms. Example:
g = @ode_def LorenzExample begin
dx = σ*(y-x)
dy = x*(ρ-z) - y
dz = x*y - β*z
end σ=10.0 ρ=28.0 β=(8/3)
g.vector_ex
begin # console, line 2:
du[:,1] = 10.0 * (u[:,2] - u[:,1]) # console, line 3:
du[:,2] = u[:,1] * (28.0 - u[:,3]) - u[:,2] # console, line 4:
du[:,3] = u[:,1] * u[:,2] - (8 / 3) * u[:,3]
end
println(g.vector_ex_return)
begin # console, line 2:
du1 = 10.0 * (u[:,2] - u[:,1]) # console, line 3:
du2 = u[:,1] * (28.0 - u[:,3]) - u[:,2] # console, line 4:
du3 = u[:,1] * u[:,2] - (8 / 3) * u[:,3]
hcat(du1,du2,du3)
endTo finish, the @. macro needs to be applied to each line, so that way it's .* and not *. But @. needs v0.6, so this will wait. For now, testing should just use the hand-created form, but this will definitely boost usability.
@oxinabox is it okay if it has .=?
@akaysh keeping you informed.
Is the recommended style to define a jacobian still:
(p::LotkaVolterra)(::Type{Val{:jac}},t,u,J)
It seems, at least for CVODE_BDF, that a jac field is instead required.
Hi,
I am trying to use ode_def_opts directly rather than the different provided macros. Rather than trying to customize the options as suggested in your README, I want to circumvent the lack of intermediate calculation by doing expressions manipulation (replacing a long subexpression using interpolation) and passing the resulting expression to ode_def_opts. I tried the very simple following example:
opts = Dict{Symbol,Bool}(
:build_tgrad => true,
:build_jac => true,
:build_expjac => false,
:build_invjac => false,
:build_invW => false,
:build_hes => false,
:build_invhes => false,
:build_dpfuncs => true)
eval(ode_def_opts(:FF, opts, :(df = 0.1*f)))But the eval fails (see the end of the post). Since I am new to Julia I guess, I am misunderstanding something about macro evaluation, since the following works:
@ode_def(FF, :(df = 0.1*f))I looked at the macroexpansion of @ode_def(FF, :(df = 0.1*f)) and it is indeed different from what I get from ode_def_opts(:FF, opts, :(df = 0.1*f)) but I do not know how to go from one to the other.
I am running on Julia 1.1 and a freshly installed ParameterizedFunctions package.
Evaluation error:
ERROR: syntax: invalid syntax (escape (block (method #0=(outerref FF)) (block (method FF (call (core svec) (call (core svec) (call (core Typeof) #0#)) (call (core svec))) (lambda (#self#) (((#self# #1=(core Any) 0) (#56 #1# 18) (#57 #1# 18) (#58 #1# 18) (#59 #1# 18)) () 0 ()) (block (line 72 /Users/mdartiailh/.julia/packages/ParameterizedFunctions/ozDxQ/src/maketype.jl) (newvar #56) (newvar #57) (newvar #58) (newvar #59) (call (outerref FF) (block (null) (block (= #56 (new ##56#60)) (null) (unnecessary #56))) #2=(outerref nothing) (block (null) (block (= #57 (new ##57#61)) (null) (unnecessary #57))) (block (null) (block (= #58 (new ##58#62)) (null) (unnecessary #58))) #2# #2# (block (null) (block (= #59 (new ##59#63)) (null) (unnecessary #59))) #<julia: LinearAlgebra.UniformScaling{Bool}(λ=true)> #2# (copyast (inert (= df (call * #<julia: 0.1> f)))) #<julia: Array{Expr, (1,)}[Expr(:call, :, 0.1, 1)]> #<julia: Array{Expr, (0,)}[]> #<julia: Array{Expr, (0,)}[]> #<julia: Array{Symbol, (0,)}[]> #<julia: Array{Any, (0, 0)}[]> #<julia: Array{Expr, (1,)}[Expr(:call, :, 0, 1)]> (copyast (inert (block (= (ref internal_var___grad 1) (call * 0 1)) (null)))) (copyast (inert (block (null)))) (copyast (inert (call error #<julia: "Exponential Jacobian Does Not Exist">))) (copyast (inert (block (null)))) (copyast (inert (call error #<julia: "Inverse Jacobian Does Not Exist">))) (copyast (inert (call error #<julia: "Inverse Rosenbrock-W Does Not Exist">))) (copyast (inert (call error #<julia: "Inverse Rosenbrock-W Transformed Does Not Exist">))) (copyast (inert (call error #<julia: "Hessian Does Not Exist">))) (copyast (inert (call error #<julia: "Inverse Hessian Does Not Exist">))) (copyast (inert (= df (call * #<julia: 0.1> f) (null)))) (copyast (inert (= df (call * #<julia: 0.1> f)))) (copyast (inert (= df (call * #<julia: 0.1> f)))) (copyast (inert (= df (call * #<julia: 0.1> f) (call hcat)))) #<julia: Array{Symbol, (0,)}[]>))))) (unnecessary #0#)))
Essentially just need to find this out, and document it for users:
Please update this package to work with julia 1.9.
ERROR: LoadError: ArgumentError: Package ParameterizedFunctionsExt does not have ParameterizedFunctions in its dependencies:
- You may have a partially installed environment. Try `Pkg.instantiate()`
to ensure all packages in the environment are installed.
- Or, if you have ParameterizedFunctionsExt checked out for development and have
added ParameterizedFunctions as a dependency but haven't updated your primary
environment's manifest file, try `Pkg.resolve()`.
- Otherwise you may need to report an issue with ParameterizedFunctionsExt
Stacktrace:
[1] macro expansion
@ ./loading.jl:1597 [inlined]
[2] macro expansion
@ ./lock.jl:267 [inlined]
[3] require(into::Module, mod::Symbol)
@ Base ./loading.jl:1574
[4] top-level scope
@ ~/.julia/packages/Latexify/kPsTM/ext/ParameterizedFunctionsExt.jl:4
[5] include
@ ./Base.jl:457 [inlined]
[6] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::String)
@ Base ./loading.jl:2012
[7] top-level scope
@ stdin:2
in expression starting at /Users/bryan/.julia/packages/Latexify/kPsTM/ext/ParameterizedFunctionsExt.jl:1
in expression starting at stdin:2
┌ Error: Error during loading of extension ParameterizedFunctionsExt of Latexify, use `Base.retry_load_extensions()` to retry.
│ exception =
│ 1-element ExceptionStack:
│ Failed to precompile ParameterizedFunctionsExt [18ff8e20-bf52-57ba-a972-04d5fc044831] to "/Users/bryan/.julia/compiled/v1.9/ParameterizedFunctionsExt/jl_x5s81O".
│ Stacktrace:
│ [1] error(s::String)
│ @ Base ./error.jl:35
│ [2] compilecache(pkg::Base.PkgId, path::String, internal_stderr::IO, internal_stdout::IO, keep_loaded_modules::Bool)
│ @ Base ./loading.jl:2262
│ [3] compilecache
│ @ ./loading.jl:2129 [inlined]
│ [4] _require(pkg::Base.PkgId, env::Nothing)
│ @ Base ./loading.jl:1772
│ [5] _require_prelocked(uuidkey::Base.PkgId, env::Nothing)
│ @ Base ./loading.jl:1623
│ [6] _require_prelocked(uuidkey::Base.PkgId)
│ @ Base ./loading.jl:1621
│ [7] run_extension_callbacks(extid::Base.ExtensionId)
│ @ Base ./loading.jl:1194
│ [8] run_extension_callbacks()
│ @ Base ./loading.jl:1252
│ [9] _require_prelocked(uuidkey::Base.PkgId, env::Nothing)
│ @ Base ./loading.jl:1636
│ [10] _require_prelocked(uuidkey::Base.PkgId)
│ @ Base ./loading.jl:1621
│ [11] run_extension_callbacks(extid::Base.ExtensionId)
│ @ Base ./loading.jl:1194
│ [12] run_extension_callbacks()
│ @ Base ./loading.jl:1252
│ [13] _require_prelocked(uuidkey::Base.PkgId, env::String)
│ @ Base ./loading.jl:1636
│ [14] macro expansion
│ @ ./loading.jl:1611 [inlined]
│ [15] macro expansion
│ @ ./lock.jl:267 [inlined]
│ [16] require(into::Module, mod::Symbol)
│ @ Base ./loading.jl:1574
│ [17] include(fname::String)
│ @ Base.MainInclude ./client.jl:478
│ [18] top-level scope
│ @ ~/src/tibra/Tibra.jl/scripts/run_tibrax_server.jl:4
│ [19] include(mod::Module, _path::String)
│ @ Base ./Base.jl:457
│ [20] exec_options(opts::Base.JLOptions)
│ @ Base ./client.jl:307
│ [21] _start()
│ @ Base ./client.jl:522
└ @ Base loading.jl:1200
Onto parameterized functions.md, at
g = LotkaVolterra(a=0.3,b=20.3)
I get:
LoadError: InexactError()
while loading In[5], in expression starting on line 1
in ParameterizedFunctions.LotkaVolterra(::Expr, ::Array{Expr,1}, ::Array{SymEngine.Basic,1}, ::Array{Expr,1}, ::Array{Expr,1}, ::Array{Symbol,1}, ::Array{SymEngine.Basic,1}, ::Array{SymEngine.Basic,2}, ::Array{SymEngine.Basic,2}, ::Array{SymEngine.Basic,2}, ::Array{SymEngine.Basic,2}, ::Array{SymEngine.Basic,2}, ::Array{SymEngine.Basic,2}, ::Array{SymEngine.Basic,2}, ::Array{SymEngine.Basic,2}, ::Expr, ::Expr, ::Expr, ::Expr, ::Expr, ::Expr, ::Expr, ::Expr, ::Expr, ::Expr, ::Expr, ::Array{Symbol,1}, ::Float64, ::Float64, ::Int64) at C:\Users\Denis.julia\v0.5\ParameterizedFunctions\src\maketype.jl:25
in #LotkaVolterra#14(::Expr, ::Array{Expr,1}, ::Array{SymEngine.Basic,1}, ::Array{Expr,1}, ::Array{Expr,1}, ::Array{Symbol,1}, ::Array{SymEngine.Basic,1}, ::Array{SymEngine.Basic,2}, ::Array{SymEngine.Basic,2}, ::Array{SymEngine.Basic,2}, ::Array{SymEngine.Basic,2}, ::Array{SymEngine.Basic,2}, ::Array{SymEngine.Basic,2}, ::Array{SymEngine.Basic,2}, ::Array{SymEngine.Basic,2}, ::Expr, ::Expr, ::Expr, ::Expr, ::Expr, ::Expr, ::Expr, ::Expr, ::Expr, ::Expr, ::Expr, ::Array{Symbol,1}, ::Float64, ::Float64, ::Int64, ::Type{T}) at C:\Users\Denis.julia\v0.5\ParameterizedFunctions\src\maketype.jl:72
in (::Core.#kw#Type)(::Array{Any,1}, ::Type{ParameterizedFunctions.LotkaVolterra}) at .<missing>:0
Now that the ODE story is complete, this should tackle DAEs.
dx to x' so that way x'' etc. can be defined.x' + y' = 2xyM(t,y)After these ideas are handled,
This will require returning a type which can give this information (or maybe define the correct DAE types). The mass matrix side could use the current macros since that actually will work with M being a matrix of SymEngine.Basic's.
This function, which I think should be okay,
f = @ode_def FFF begin
dx = -p
dy = 1.0
end p=>2.0
gives the following error when loading the file:
WARNING: Jacobian could not invert
ERROR: LoadError: syntax: function argument names not unique
Stacktrace:
[1] include_from_node1(::String) at ./loading.jl:569
[2] include(::String) at /opt/Julia-0.6.app/Contents/Resources/julia/lib/julia/sys.dylib:?
while loading /Users/kirill/Sandboxes/Julia-Misc/ODE1.jl, in expression starting on line 28
It seems you can't have a parameter named "p", because if I change the "p" to "a", it loads just fine.
Dear JuliaDiffEq-Team,
thanks for all the great work you are doing! It's really fun to work your packages! Here is an error I just encountered, I guess it has to do with a recent renaming of invW into Wfact in DiffEqBase
myode = @ode_def begin
dX = -k*X
end k
myprob = ODEProblem(myode, ones(1), 1., ones(1))
solve(myprob, Rosenbrock23())Best, Daniel
f = @ode_def LotkaVolterra begin
dx = ax - bxy
dy = -cy + dxy
end a=>1.5 b=>1 c=3 d=1
If my solver calls this function, is there a way to see how many times 'f' is called ?
Thanks
ParameterizedFunctions.jl's @ode_def DSL needs a slight overhaul. Specifically, I would like to see if a nice syntax can make it handle differential-algebraic equations, delay differential equations, higher order differential equations, intermediate computations, internal functions, order reduction of DAEs, etc. If we are capable, having it describe PDEs would be amazing as well. Essentially, something that can take a very general looking "ODE", and make it spit out something to solve.
This would handle issues #5, #11, and others which haven't been written down.
The question is, what is a syntax which is easy for humans to understand, but is easily parsable to equation types? That is the first step. Making use of this representation to do all of the more advanced behavior can come later, but first we just need a parsable syntax.
My first proposal is something like this:
Let x' stand for the derivative. x'' etc. stand for higher order derivatives. We'll leave it open for now how to do nth order derivatives in an easier way.
Let x and x' alias for x(t) and x'(t). The first job in parsing would be to do this conversion.
So then the general equation has x(t) for dependent variables, and the independent variable defaults to t. There should be a way for the user to change the symbol for the independent variable, or make it a tuple of symbols for multiple independent variables (for PDEs).
For describing PDEs, x' will default to being the derivative of the first variable. But more generally, derivatives would be written as x_t for a single derivative, or x_tt etc. for more. Again, this parses to x_t(t). Later we can add special operators like Δ which expands to u_xx + u_yy + ... using all of the not first dependent variable (first is always assumed to be time).
So for ODEs we would have x' -> x'(t) -> x_t(t) as the internal form. This should work for PDEs? This also lets one specify delays, since would could directly write x'(t-2), or x'(t-y') to go more generally.
An example would look like:
f = @ode_def LotkaVolterra begin
x' = a*x - b*x*y
y' = -c*y + d*x*y
end a=>1.5 b=>1 c=3 d=1for something basic, or one could write the DAE
f = @ode_def LotkaVolterra begin
x' + y' = a*x - b*x*y
y' = -c*y + d*x*y
end a=>1.5 b=>1 c=3 d=1or one could write the neutral delay equation
f = @ode_def LotkaVolterra begin
x' + y' = a*x(t-y') - b*x*y
y' = -c*y + d*x*y
end a=>1.5 b=>1 c=3 d=1However, the question to answer is, can this actually be unambiguously parsed?
First of all, how does one determine the dependent variables? By not allowing DAEs in the previous version of the macro, I could just assume that the dependent variables would be known by checking the left-and side. However, with DAEs, the formulation
f = @ode_def LotkaVolterra begin
0 = - x' - y' + a*x(t-y') - b*x*y
y' = -c*y + d*x*y
end a=>1.5 b=>1 c=3 d=1is perfectly valid. Also, for DAEs, not every term has to have a derivative term, so is it possible to parse out what the independent variables are supposed to be? Also, is the x_t form easy to parse, or would that cause a lot of potential problems? It can only _ then do some finite number of the dependent variables, so that seems doable.
I would like some input on others for what a good syntax would be. I'm happy to give example equations if one would like to have a few to think about.
Currently this uses eval and then exports the type. While this seems to work, it has a side-effect of causing some variables to become symbols during the SymEngine part. This could be made safer so as not to effect external codes. Also, I don't know if the eval is truly necessary: a properly quoted macro may be able to handle it without evals. Someone with more macro-foo might want to take a look at these parts.
It would be nice if, when a line doesn't start with d__ = ___, that it will just ignore the line (but still capture the parameters). This is so you could make an intermediate variable, like r = ... and use r in further calculations.
Functions with parameters for differnetial equations
@JuliaRegistrator register()
This typo (an = instead of a +), and a few others, can reliably segfault for me on julia 0.6.2:
f2 = @ode_def_nohes LotkaVolterraAll begin
dx = a*x = b*x*y
dy = -c*y + d*x*y
end a b c dNot a huge problem in practise, just surprising! I guess its really a symengine problem, this issue is more just to document that this can happen quite easily with these macros.
signal (11): Segmentation fault
while loading no file, in expression starting on line 0
basic_diff at /home/raf/.julia/v0.6/Conda/deps/usr/lib/libsymengine.so.0.3 (unknown line)
diff at /home/raf/.julia/v0.6/SymEngine/src/calculus.jl:12
unknown function (ip: 0x7fcdd70efb96)
jl_apply_generic at /usr/lib/libjulia.so.0.6 (unknown line)
diff at /home/raf/.julia/v0.6/SymEngine/src/calculus.jl:22
collect at ./array.jl:475
#ode_def_opts#1 at /home/raf/.julia/v0.6/ParameterizedFunctions/src/ode_def_opts.jl:103
jl_apply_generic at /usr/lib/libjulia.so.0.6 (unknown line)
jl_f__apply at /usr/lib/libjulia.so.0.6 (unknown line)
ode_def_opts at /home/raf/.julia/v0.6/ParameterizedFunctions/src/ode_def_opts.jl:4
jl_apply_generic at /usr/lib/libjulia.so.0.6 (unknown line)
jl_f__apply at /usr/lib/libjulia.so.0.6 (unknown line)
@ode_def_nohes at /home/raf/.julia/v0.6/ParameterizedFunctions/src/macros.jl:37
Julia Version 0.6.2
Commit d386e40 (2017-12-13 18:08 UTC)
Platform Info:
OS: Linux (x86_64-pc-linux-gnu)
CPU: Intel(R) Core(TM) i7-2640M CPU @ 2.80GHz
WORD_SIZE: 64
BLAS: libopenblas (DYNAMIC_ARCH NO_AFFINITY Sandybridge)
LAPACK: libopenblas
LIBM: libm
LLVM: libLLVM-3.9.1 (ORCJIT, sandybridge)
@JuliaRegistrator register()
Users should be noticed not to used the reserved names u, du, p and t.
Changing these names to something less frequently used could be also helpful.
How to code the Lorenz problem with the data generation code inside the problem such that the Signal to Noise Ratio (SNR) is an additional parameter to be estimated.
g1 = @ode_def_nohes LorenzExample begin
dx = σ*(y-x)
dy = x*(ρ-z) - y
dz = x*(y) - β*z
end σ=>10.0 ρ=>28.0 β=>2.66667 # Parameters used to construct the dataset
r0 = [0.1; 0.0; 0.0] # Initial values of the system in space
tspan = (0.0, 4.0)
prob = ODEProblem(g1, r0, tspan)
#snr => [0.05]
data_sol = solve(prob,Vern7(),saveat=t,reltol=1e-12,abstol=1e-12)
data = vecarr_to_arr(data_sol)
data .+= snr.*randn(size(data)) # Noise added to signal from ODE system as required
The parameter estimation should check that 'snr' is the 'observed' value built in the data. A coding for snr => 0.05 similar to σ=>10.0 ρ=>28.0 and β=>2.66667
Related to #36, some method must not have been updated after the addition of a parameter vector. The error occurs when you define a model using ParameterizedFunctions and try to solve it using both callbacks and some Rosenbrock algorithm.
ode = @ode_def test begin
dx = p - x
end p
condition(u, t, i) = t - 3
affect!(i) = nothing
cb = ContinuousCallback(condition, affect!)
prob = ODEProblem(ode, [1.], (0., 10.), [1.])
sol = solve(prob, Rosenbrock23(); callback=cb)
MethodError: no method matching (::test)(::Type{Val{:invW}}, ::Float64, ::Array{Float64,1}, ::Float64, ::Array{Float64,2})
Closest candidates are:
test(::Type{Val{:invW}}, ::Any, ::Any, ::Any, ::Any, ::Any) at /home/Niklas/.julia/v0.6/ParameterizedFunctions/src/ode_def_opts.jl:321
test(::Any, ::Any, ::Any, ::Number) at /home/Niklas/.julia/v0.6/ParameterizedFunctions/src/ode_def_opts.jl:259
test(::Type{Val{:tgrad}}, ::Any, ::Any, ::Any, ::Any) at /home/Niklas/.julia/v0.6/ParameterizedFunctions/src/ode_def_opts.jl:294
...
Right now the out of place form exists for ParameterizedFunctions, but it isn't able to make use of static arrays.
using ParameterizedFunction in the Lotka-Volterra example gives the following error:
LoadError: ArgumentError: Module ParameterizedFunction not found in current path.
Run Pkg.add("ParameterizedFunction") to install the ParameterizedFunction package.
while loading In[1], in expression starting on line 1
in require(::Symbol) at .\loading.jl:365
Then Pkg.add("ParameterizedFunction") gives:
ERROR: unknown package ParameterizedFunction
I got a problem, where the boundary conditions depend on parameters also.
Can I use the '@ode_def' macro also?
I think it would be good to separate the parsing / defining core of ParameterizedFunctions.jl from the symbolic calculation add-on of SymEngine. One reason for this is that many people seem to have build issues with SymEngine, so this would be able to make these extra enhancements optional to DifferentialEquations.jl without the full removal of ParameterizedFunctions.jl, and it would allow for very small builds which will help with the DiffEqOnline web deployment.
The implementation is pretty simple: move out this try/catch block
https://github.com/JuliaDiffEq/ParameterizedFunctions.jl/blob/master/src/ode_def_opts.jl#L80
However, it means that the macros which use this functionality will break. @tkelman, would it be okay to not have that library as a requirement (due to the build/size issues), have these extra macros broken, and throw an error telling the user to install some ParameterizedFunctionsSymEngine.jl to use them? Or is that not considered good form?
If I define a small system:
using DifferentialEquations
f2 = @ode_def test begin
dx = p_x - d_x*x
end p_x d_x
p = [1., 2.]
u0 = [1.0]
tspan = (0.0,10.0)
prob = ODEProblem(f2,u0,tspan,p)
then
sol = solve(prob, Tsit5())works, but
sol = solve(prob, Rosenbrock23())or any other stiff solver that I have tried results in:
MethodError: no method matching (::test)(::Type{Val{:tgrad}}, ::Float64, ::Array{Float64,1}, ::Array{Float64,1})
Closest candidates are:
test(::Type{Val{:tgrad}}, ::Any, ::Any, ::Any, ::Any) at /home/Niklas/.julia/v0.6/ParameterizedFunctions/src/ode_def_opts.jl:294
test(::Type{Val{:jac}}, ::Any, ::Any, ::Any, ::Any) at /home/Niklas/.julia/v0.6/ParameterizedFunctions/src/ode_def_opts.jl:300
test(::Type{Val{:invjac}}, ::Any, ::Any, ::Any, ::Any) at /home/Niklas/.julia/v0.6/ParameterizedFunctions/src/ode_def_opts.jl:316
...
Which version of Julia is this package compatible with? It doesn't work for 0.5-rc4.
julia> Pkg.test("ParameterizedFunctions")
INFO: Testing ParameterizedFunctions
ERROR: LoadError: LoadError: syntax: "(x::Sym,y::Sym)" is not a valid function argument name
in include_from_node1(::String) at ./loading.jl:488 (repeats 2 times)
in macro expansion; at ./none:2 [inlined]
in anonymous at ./<missing>:?
in eval(::Module, ::Any) at ./boot.jl:234
in process_options(::Base.JLOptions) at ./client.jl:239
in _start() at ./client.jl:318
while loading /home/pawel/.julia/v0.5/SymPy/src/logical.jl, in expression starting on line 5
while loading /home/pawel/.julia/v0.5/SymPy/src/SymPy.jl, in expression starting on line 123
ERROR: LoadError: LoadError: Failed to precompile SymPy to /home/pawel/.julia/lib/v0.5/SymPy.ji.
in compilecache(::String) at ./loading.jl:593
in require(::Symbol) at ./loading.jl:422
in include_from_node1(::String) at ./loading.jl:488
in eval(::Module, ::Any) at ./boot.jl:234
in require(::Symbol) at ./loading.jl:415
in include_from_node1(::String) at ./loading.jl:488
in process_options(::Base.JLOptions) at ./client.jl:262
in _start() at ./client.jl:318
while loading /home/pawel/.julia/v0.5/ParameterizedFunctions/src/ParameterizedFunctions.jl, in expression starting on line 2
while loading /home/pawel/.julia/v0.5/ParameterizedFunctions/test/runtests.jl, in expression starting on line 1
=======================[ ERROR: ParameterizedFunctions ]========================
failed process: Process(`/home/pawel/Sources/julia/usr/bin/julia -Cnative -J/home/pawel/Sources/julia/usr/lib/julia/sys.so --compile=yes --depwarn=yes --check-bounds=yes --code-coverage=none --color=yes --compilecache=yes /home/pawel/.julia/v0.5/ParameterizedFunctions/test/runtests.jl`, ProcessExited(1)) [1]
================================================================================
ERROR: ParameterizedFunctions had test errors
in #test#61(::Bool, ::Function, ::Array{AbstractString,1}) at ./pkg/entry.jl:740
in (::Base.Pkg.Entry.#kw##test)(::Array{Any,1}, ::Base.Pkg.Entry.#test, ::Array{AbstractString,1}) at ./<missing>:0
in (::Base.Pkg.Dir.##2#3{Array{Any,1},Base.Pkg.Entry.#test,Tuple{Array{AbstractString,1}}})() at ./pkg/dir.jl:31
in cd(::Base.Pkg.Dir.##2#3{Array{Any,1},Base.Pkg.Entry.#test,Tuple{Array{AbstractString,1}}}, ::String) at ./file.jl:59
in #cd#1(::Array{Any,1}, ::Function, ::Function, ::Array{AbstractString,1}, ::Vararg{Array{AbstractString,1},N}) at ./pkg/dir.jl:31
in (::Base.Pkg.Dir.#kw##cd)(::Array{Any,1}, ::Base.Pkg.Dir.#cd, ::Function, ::Array{AbstractString,1}, ::Vararg{Array{AbstractString,1},N}) at ./<missing>:0
in #test#3(::Bool, ::Function, ::String, ::Vararg{String,N}) at ./pkg/pkg.jl:258
in test(::String, ::Vararg{String,N}) at ./pkg/pkg.jl:258I have the below error after updating to DifferentialEquations 1.5.0-
There is no ParameterizedFunctions.ji file to delete. Any idea what is going on here?
using DifferentialEquations
INFO: Recompiling stale cache file /Users/Adam/.julia/lib/v0.5/MacroTools.ji for module MacroTools.
INFO: Recompiling stale cache file /Users/Adam/.julia/lib/v0.5/DataFrames.ji for module DataFrames.
INFO: Recompiling stale cache file /Users/Adam/.julia/lib/v0.5/DiffEqBase.ji for module DiffEqBase.
INFO: Recompiling stale cache file /Users/Adam/.julia/lib/v0.5/StochasticDiffEq.ji for module StochasticDiffEq.
INFO: Recompiling stale cache file /Users/Adam/.julia/lib/v0.5/FiniteElementDiffEq.ji for module FiniteElementDiffEq.
INFO: Recompiling stale cache file /Users/Adam/.julia/lib/v0.5/DiffEqDevTools.ji for module DiffEqDevTools.
INFO: Recompiling stale cache file /Users/Adam/.julia/lib/v0.5/OrdinaryDiffEq.ji for module OrdinaryDiffEq.
INFO: Recompiling stale cache file /Users/Adam/.julia/lib/v0.5/AlgebraicDiffEq.ji for module AlgebraicDiffEq.
INFO: Recompiling stale cache file /Users/Adam/.julia/lib/v0.5/StokesDiffEq.ji for module StokesDiffEq.
INFO: Recompiling stale cache file /Users/Adam/.julia/lib/v0.5/DiffEqParamEstim.ji for module DiffEqParamEstim.
INFO: Recompiling stale cache file /Users/Adam/.julia/lib/v0.5/DiffEqSensitivity.ji for module DiffEqSensitivity.
INFO: Recompiling stale cache file /Users/Adam/.julia/lib/v0.5/Sundials.ji for module Sundials.
INFO: Recompiling stale cache file /Users/Adam/.julia/lib/v0.5/ParameterizedFunctions.ji for module ParameterizedFunctions.
ERROR: LoadError: Declaring __precompile__(false) is not allowed in files that are being precompiled.
in __precompile__(::Bool) at ./loading.jl:300
in include_from_node1(::String) at ./loading.jl:488
in include_from_node1(::String) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?
in macro expansion; at ./none:2 [inlined]
in anonymous at ./<missing>:?
in eval(::Module, ::Any) at ./boot.jl:234
in eval(::Module, ::Any) at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?
in process_options(::Base.JLOptions) at ./client.jl:239
in _start() at ./client.jl:318
in _start() at /Applications/Julia-0.5.app/Contents/Resources/julia/lib/julia/sys.dylib:?
while loading /Users/Adam/.julia/v0.5/ParameterizedFunctions/src/ParameterizedFunctions.jl, in expression starting on line 1
I'm trying to use ode_def without a name and I'm getting this error:
Here are my versions:
These are used in methods like exponential Rosenbrock methods. However, this method is currently missing from SymEngine so the functionality is "all written" but disabled since expm(gamma*symjac) doesn't have a dispatch. When SymEngine adds this, then the booleans in the options can be switched and it will exist.
Sometimes it is nice to have a parameterized function act like a regular function from languages like Python/Matlab/R, where the signature would be f(t, u) -> du instead of having to do the, more efficient, fortran/C way of doing the output inplace f(t, u, du).
It will be useful to have an option to provide input parameters for the ODE system defined via @ode_def through separate file like:
pf = @ode_def Test begin
...
end init_params.txt
and init_params can contain parameters defined via inlining or =>
a=2
b=3
c=>5
..
etc
I am trying to use DifferentialEquations.jl version 3.X and everything was fine until some of my package versions were updated. Now I cannot reproduce my previous environment. I removed ~/.julia/v0.6/ and installed the following versions with Pkg.add, Pkg.pin.
julia> Pkg.status()
2 required packages:
- DifferentialEquations 3.1.0 pinned.3db2976b.tmp
- ParameterizedFunctions 2.3.1 pinned.57f45fb5.tmp
88 additional packages:
- AlgebraicDiffEq 0.1.0
- BandedMatrices 0.3.1
- BinDeps 0.8.6
- BinaryProvider 0.2.3
- BoundaryValueDiffEq 1.0.0
- Calculus 0.2.2
- ChunkedArrays 0.1.1
- CommonSubexpressions 0.0.1
- Compat 0.54.0
- Conda 0.7.1
- DataStructures 0.7.4
- DelayDiffEq 2.1.0
- DiffBase 0.3.2
- DiffEqBase 3.6.0
- DiffEqBiological 2.0.0
- DiffEqCallbacks 1.0.0
- DiffEqDevTools 1.0.0
- DiffEqDiffTools 0.4.0
- DiffEqFinancial 1.0.0
- DiffEqJump 1.1.0
- DiffEqMonteCarlo 0.10.0
- DiffEqNoiseProcess 1.0.0
- DiffEqPDEBase 0.4.0
- DiffEqParamEstim 1.0.0
- DiffEqPhysics 1.0.0
- DiffEqSensitivity 1.0.1
- DiffEqUncertainty 0.1.0
- DiffResults 0.0.3
- DiffRules 0.0.3
- DimensionalPlotRecipes 0.0.2
- Distances 0.5.0
- DistributedArrays 0.4.0
- Distributions 0.15.0
- EllipsisNotation 0.3.0
- FiniteElementDiffEq 0.5.0
- ForwardDiff 0.7.3
- FunctionWrappers 0.1.0
- GenericSVD 0.1.0
- IterativeSolvers 0.5.0
- IteratorInterfaceExtensions 0.0.2
- JSON 0.16.4
- Juno 0.4.0
- LearnBase 0.1.6
- LineSearches 3.2.5
- LinearMaps 1.0.4
- LossFunctions 0.2.0
- LsqFit 0.3.0
- MacroTools 0.4.0
- Media 0.3.0
- Missings 0.2.7
- MuladdMacro 0.0.2
- MultiScaleArrays 0.6.0
- NLSolversBase 4.3.0
- NLsolve 1.0.1
- NaNMath 0.3.1
- NamedTuples 4.0.0
- Nullables 0.0.3
- Optim 0.14.0
- OptimBase 1.0.0
- OrdinaryDiffEq 3.2.0
- PDMats 0.8.0
- Parameters 0.8.1
- PenaltyFunctions 0.0.2
- PositiveFactorizations 0.1.0
- Primes 0.2.0
- QuadGK 0.2.0
- RandomNumbers 0.1.1
- RecipesBase 0.2.3
- RecursiveArrayTools 0.14.6
- Reexport 0.1.0
- Requires 0.4.3
- ResettableStacks 0.3.1
- Rmath 0.3.2
- Roots 0.5.0
- SHA 0.5.6
- SimpleTraits 0.6.0
- SortingAlgorithms 0.2.0
- SpecialFunctions 0.3.8
- StaticArrays 0.6.6
- StatsBase 0.20.0
- StatsFuns 0.5.0
- SteadyStateDiffEq 0.2.0
- StochasticDiffEq 3.0.0
- Sundials 1.3.0
- SymEngine 0.3.0
- TableTraits 0.1.0
- URIParser 0.3.0
- VectorizedRoutines 0.0.2Now when I run Pkg.test("ParameterizedFunctions") I get the following errors.
julia> Pkg.test("ParameterizedFunctions")
INFO: Computing test dependencies for ParameterizedFunctions...
INFO: Installing DiffEqProblemLibrary v1.0.0
INFO: Building Conda
INFO: Building SymEngine
INFO: Building DiffEqBase
INFO: ~~~ DifferentialEquations.jl *BREAKING* changes ~~~
We have changed the front-end API on how
users may define equations of motion and
problems, for all problem types that can
be used in the DifferentialEquations.jl.
These are *BREAKING* changes, and they
also have *NO WARNINGS*!
Please see our latest documentation here:
http://docs.juliadiffeq.org/latest/
or the blogpost that describes the changes:
http://juliadiffeq.org/2018/01/24/Parameters.html
In short, the mutated argument is the first argument,
and parameters are now directly passed
into the equations of motion function. For all
types now mutation goes first, then dependent variables,
then parameters, then independent variables.
`f(mutated, dependent variables, p/integrator, independent variables)`
For example, this means that the ODE syntax will be `f(u,p,t)` (for the
out-of-place) and `f(du,u,p,t)` (for the in-place). Notice
that this change also removes the need for ParameterizedFunctions
as now parameters are part of the equations of motion.
For more details please visit the above links!
INFO: Building SpecialFunctions
INFO: Building Rmath
INFO: Testing ParameterizedFunctions
Build some examples
Test Values
Error During Test
Test threw an exception of type UndefVarError
Expression: param_values(f_t) == Real[1.5, 1]
UndefVarError: param_values not defined
Stacktrace:
[1] include_from_node1(::String) at ./loading.jl:576
[2] include(::String) at ./sysimg.jl:14
[3] process_options(::Base.JLOptions) at ./client.jl:305
[4] _start() at ./client.jl:371
ERROR: LoadError: There was an error during testing
while loading /Users/mcfefa/.julia/v0.6/ParameterizedFunctions/test/runtests.jl, in expression starting on line 46
=========================================[ ERROR: ParameterizedFunctions ]=========================================
failed process: Process(`/Applications/Julia-0.6.app/Contents/Resources/julia/bin/julia -Ccore2 -J/Applications/Julia-0.6.app/Contents/Resources/julia/lib/julia/sys.dylib --compile=yes --depwarn=yes --check-bounds=yes --code-coverage=none --color=yes --compilecache=yes /Users/mcfefa/.julia/v0.6/ParameterizedFunctions/test/runtests.jl`, ProcessExited(1)) [1]
===================================================================================================================
INFO: Removing DiffEqProblemLibrary v1.0.0
ERROR: ParameterizedFunctions had test errorsAlong with the following errors:
julia> using ParameterizedFunctions
julia> ParameterizedFunction
ERROR: UndefVarError: ParameterizedFunction not definedI haven't been able to update my code for DifferentialEquations v4.0 yet.
How can I get an environment with DifferentialEquations v3.X working?
I'm getting a strange problem when trying to use a model defined with @ode_def within a worker process on Julia 0.7 only (no issues in 1.0). I've managed to strip it down to the following reproducible example:
Contents of model.jl:
using ParameterizedFunctions
model = @ode_def MyModel begin
dX = -a * Y
dY = b * X
end a bContents of test.jl:
using Distributed
addprocs(1)
@everywhere include("model2.jl")
@show model([1., 2.], [3., 4.], 0.)
@show @fetch model([1., 2.], [3., 4.], 0.)All this does is try to evaluate the model function once in the main process and once in the worker process. Running with Julia 1.0.2 gives the expected output:
model([1.0, 2.0], [3.0, 4.0], 0.0) = [-6.0, 4.0]
#= /home/me/stuff/test.jl:9 =# @fetch(model([1.0, 2.0], [3.0, 4.0], 0.0)) = [-6.0, 4.0]
However with 0.7 I get the following warning:
model([1.0, 2.0], [3.0, 4.0], 0.0) = [-6.0, 4.0]
┌ Warning: `finalizer(o, f::Function)` is deprecated, use `finalizer(f, o)` instead.
│ caller = serialize_global_from_main(::Distributed.ClusterSerializer{Sockets.TCPSocket}, ::Symbol) at clusterserialize.jl:154
└ @ Distributed /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v0.7/Distributed/src/clusterserialize.jl:154
┌ Warning: `finalizer(o, f::Function)` is deprecated, use `finalizer(f, o)` instead.
│ caller = finalizer(::Function, ::Function) at deprecated.jl:55
└ @ Base ./deprecated.jl:55
The main process then locks up at 100% cpu (0% on worker) and needs to be terminated.
I am using ParameterizedFunctions.jl v4.0.0 with Julia 1.0 and v3.10.0 with 0.7.
It would be nice to be able to accept a=2*pi inside of the parameters.
Similar to #11 . This would allow for time-verying parameters:
f = @ode_def LotkaVolterra begin
a = t*1.5
dx = a*x - b*x*y
dy = -c*y + d*x*y
end a=>0 b=>1 c=3 d=1ode_def_opts seems to be very useful function when ODEs, parameters, etc are imported from some input file (or DB). However I have difficulties with the syntax. E.x.:
using DiffEqBase, OrdinaryDiffEq, ParameterizedFunctions
const opts = Dict{Symbol,Bool}(
:build_tgrad => false,
:build_jac => false,
:build_expjac => false,
:build_invjac => false,
:build_invW => false,
:build_hes => false,
:build_invhes => false,
:build_dpfuncs => false)
ode1 = quote
v1 = k1*A*comp1
dA = -v1/comp1
dB = v1/comp1
end
name = :MAIN
params = [:(comp1=>1.1), :(k1=>0.01)]
pf = ode_def_opts(name, opts, ode1, params...)
u0 = [10., 0.]
tspan = (0., 1000.)
prob = ODEProblem(pf,u0,tspan)
ArgumentError: reducing over an empty collection is not allowed
Stacktrace:
[1] _mapreduce(::Base.#identity, ::Base.#scalarmax, ::IndexLinear, ::Array{Any,1}) at .\reduce.jl:265
[2] maximum(::Array{Any,1}) at .\reduce.jl:454
[3] numargs(::Expr) at C:\Julia\v0.6\DiffEqBase\src\utils.jl:13
[4] #ODEProblem#170(::Array{Any,1}, ::Type{T} where T, ::Expr, ::Array{Float64,1}, ::Tuple{Float64,Float64}) at C:\Julia\v0.6\DiffEqBase\src\problems\ode_problems.jl:26
[5] DiffEqBase.ODEProblem(::Expr, ::Array{Float64,1}, ::Tuple{Float64,Float64}) at C:\Julia\v0.6\DiffEqBase\src\problems\ode_problems.jl:26
[6] include_string(::String, ::String) at .\loading.jl:515
ParameterizedFunctions.ParameterizedFunction(pf_func,[1.5,1.0])
works
but not
ParameterizedFunction(pf_func,[1.5,1.0])
In parameterizedFunction, is it possible to have cross equation restrictions of parameters and functions of parameters in front of a variable?
Also what is the most congenial way to write a system?
F(Dy1, Dy2...y1, y2) =0 or
Dy1 = Dy2, Y1, Y2
Dy2 = Dy2, Y1, Y2
Where is the best docs on ways of formulating a problem with ParameterizedFunctions?
Sensitivity analysis won't work on the user-defined functions wrapped via the ParameterizedFunction constructor because it will not be able to evaluate the parameter Jacobian. To fix this, one simply has to define the ParamJac overload using ForwardDiff. If you want to help add this (it should be easy), see OrdinaryDiffEq.jl's Rosenbrock solvers.
Given this discussion, JuliaApproximation/SpectralTimeStepping.jl#1 (comment), it would be nice if ParameterizedFunctions could in many cases make an ODE from a PDE which is specified in a standard way, like:
u_t = u_xx + u_yy + cos(x)It could make an ApproxFun discretization and perform the symbolic ODE transforms to make it fast.
There are some evals in the construction macros. I would like those gone if possible, just to make it cleaner for precompilation (I guess there is a problem here with @eval + SymEngine?)
MWE:
van = @ode_def_all VanDerPol begin
dy = μ*((1-x^2)*y - x)
dx = 1*y
end μ
vanstiff = ODEProblem{false}(van, [0;sqrt(3)], (0.0,1.0), 1e6)
sol = solve(vanstiff, RadauIIA5())Error:
ERROR: MethodError: no method matching (::getfield(Main, Symbol("##4#10")))(::Array{Float64,1}, ::Float64, ::Float64)
Closest candidates are:
#4(::Any, ::Any, ::Any, ::Any) at /home/kanav/.julia/dev/ParameterizedFunctions/src/ode_def_opts.jl:260
Stacktrace:
[1] calc_J(::OrdinaryDiffEq.ODEIntegrator{RadauIIA5{0,true,DiffEqBase.DefaultLinSolve,DataType,Nothing,Rational{Int64},Rational{Int64}},false,Array{Float64,1},Float64,Float64,Float64,Float64,Float64,Array{Array{Float64,1},1},ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Array{Array{Array{Float64,1},1},1},ODEProblem{Array{Float64,1},Tuple{Float64,Float64},false,Float64,ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},Nothing,DiffEqBase.StandardODEProblem},RadauIIA5{0,true,DiffEqBase.DefaultLinSolve,DataType,Nothing,Rational{Int64},Rational{Int64}},OrdinaryDiffEq.InterpolationData{ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},Array{Array{Float64,1},1},Array{Float64,1},Array{Array{Array{Float64,1},1},1},OrdinaryDiffEq.RadauIIA5ConstantCache{DiffEqDiffTools.UDerivativeWrapper{ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},Float64,Float64},OrdinaryDiffEq.RadauIIA5Tableau{Float64,Float64},Float64,Float64,Array{Float64,1}}},DiffEqBase.DEStats},ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},OrdinaryDiffEq.RadauIIA5ConstantCache{DiffEqDiffTools.UDerivativeWrapper{ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},Float64,Float64},OrdinaryDiffEq.RadauIIA5Tableau{Float64,Float64},Float64,Float64,Array{Float64,1}},OrdinaryDiffEq.DEOptions{Float64,Float64,Float64,Float64,typeof(DiffEqBase.ODE_DEFAULT_NORM),typeof(LinearAlgebra.opnorm),CallbackSet{Tuple{},Tuple{}},typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN),typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE),typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK),DataStructures.BinaryHeap{Float64,DataStructures.LessThan},DataStructures.BinaryHeap{Float64,DataStructures.LessThan},Nothing,Nothing,Int64,Array{Float64,1},Array{Float64,1},Array{Float64,1}},Array{Float64,1},Float64,Nothing}, ::OrdinaryDiffEq.RadauIIA5ConstantCache{DiffEqDiffTools.UDerivativeWrapper{ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},Float64,Float64},OrdinaryDiffEq.RadauIIA5Tableau{Float64,Float64},Float64,Float64,Array{Float64,1}}, ::Bool) at /home/kanav/.julia/dev/OrdinaryDiffEq/src/derivative_utils.jl:52
[2] perform_step!(::OrdinaryDiffEq.ODEIntegrator{RadauIIA5{0,true,DiffEqBase.DefaultLinSolve,DataType,Nothing,Rational{Int64},Rational{Int64}},false,Array{Float64,1},Float64,Float64,Float64,Float64,Float64,Array{Array{Float64,1},1},ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Array{Array{Array{Float64,1},1},1},ODEProblem{Array{Float64,1},Tuple{Float64,Float64},false,Float64,ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},Nothing,DiffEqBase.StandardODEProblem},RadauIIA5{0,true,DiffEqBase.DefaultLinSolve,DataType,Nothing,Rational{Int64},Rational{Int64}},OrdinaryDiffEq.InterpolationData{ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},Array{Array{Float64,1},1},Array{Float64,1},Array{Array{Array{Float64,1},1},1},OrdinaryDiffEq.RadauIIA5ConstantCache{DiffEqDiffTools.UDerivativeWrapper{ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},Float64,Float64},OrdinaryDiffEq.RadauIIA5Tableau{Float64,Float64},Float64,Float64,Array{Float64,1}}},DiffEqBase.DEStats},ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},OrdinaryDiffEq.RadauIIA5ConstantCache{DiffEqDiffTools.UDerivativeWrapper{ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},Float64,Float64},OrdinaryDiffEq.RadauIIA5Tableau{Float64,Float64},Float64,Float64,Array{Float64,1}},OrdinaryDiffEq.DEOptions{Float64,Float64,Float64,Float64,typeof(DiffEqBase.ODE_DEFAULT_NORM),typeof(LinearAlgebra.opnorm),CallbackSet{Tuple{},Tuple{}},typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN),typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE),typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK),DataStructures.BinaryHeap{Float64,DataStructures.LessThan},DataStructures.BinaryHeap{Float64,DataStructures.LessThan},Nothing,Nothing,Int64,Array{Float64,1},Array{Float64,1},Array{Float64,1}},Array{Float64,1},Float64,Nothing}, ::OrdinaryDiffEq.RadauIIA5ConstantCache{DiffEqDiffTools.UDerivativeWrapper{ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},Float64,Float64},OrdinaryDiffEq.RadauIIA5Tableau{Float64,Float64},Float64,Float64,Array{Float64,1}}, ::Bool) at /home/kanav/.julia/dev/OrdinaryDiffEq/src/perform_step/firk_perform_step.jl:54
[3] perform_step!(::OrdinaryDiffEq.ODEIntegrator{RadauIIA5{0,true,DiffEqBase.DefaultLinSolve,DataType,Nothing,Rational{Int64},Rational{Int64}},false,Array{Float64,1},Float64,Float64,Float64,Float64,Float64,Array{Array{Float64,1},1},ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Array{Array{Array{Float64,1},1},1},ODEProblem{Array{Float64,1},Tuple{Float64,Float64},false,Float64,ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},Nothing,DiffEqBase.StandardODEProblem},RadauIIA5{0,true,DiffEqBase.DefaultLinSolve,DataType,Nothing,Rational{Int64},Rational{Int64}},OrdinaryDiffEq.InterpolationData{ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},Array{Array{Float64,1},1},Array{Float64,1},Array{Array{Array{Float64,1},1},1},OrdinaryDiffEq.RadauIIA5ConstantCache{DiffEqDiffTools.UDerivativeWrapper{ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},Float64,Float64},OrdinaryDiffEq.RadauIIA5Tableau{Float64,Float64},Float64,Float64,Array{Float64,1}}},DiffEqBase.DEStats},ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},OrdinaryDiffEq.RadauIIA5ConstantCache{DiffEqDiffTools.UDerivativeWrapper{ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},Float64,Float64},OrdinaryDiffEq.RadauIIA5Tableau{Float64,Float64},Float64,Float64,Array{Float64,1}},OrdinaryDiffEq.DEOptions{Float64,Float64,Float64,Float64,typeof(DiffEqBase.ODE_DEFAULT_NORM),typeof(LinearAlgebra.opnorm),CallbackSet{Tuple{},Tuple{}},typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN),typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE),typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK),DataStructures.BinaryHeap{Float64,DataStructures.LessThan},DataStructures.BinaryHeap{Float64,DataStructures.LessThan},Nothing,Nothing,Int64,Array{Float64,1},Array{Float64,1},Array{Float64,1}},Array{Float64,1},Float64,Nothing}, ::OrdinaryDiffEq.RadauIIA5ConstantCache{DiffEqDiffTools.UDerivativeWrapper{ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},Float64,Float64},OrdinaryDiffEq.RadauIIA5Tableau{Float64,Float64},Float64,Float64,Array{Float64,1}}) at /home/kanav/.julia/dev/OrdinaryDiffEq/src/perform_step/firk_perform_step.jl:37
[4] solve!(::OrdinaryDiffEq.ODEIntegrator{RadauIIA5{0,true,DiffEqBase.DefaultLinSolve,DataType,Nothing,Rational{Int64},Rational{Int64}},false,Array{Float64,1},Float64,Float64,Float64,Float64,Float64,Array{Array{Float64,1},1},ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Array{Array{Array{Float64,1},1},1},ODEProblem{Array{Float64,1},Tuple{Float64,Float64},false,Float64,ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},Nothing,DiffEqBase.StandardODEProblem},RadauIIA5{0,true,DiffEqBase.DefaultLinSolve,DataType,Nothing,Rational{Int64},Rational{Int64}},OrdinaryDiffEq.InterpolationData{ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},Array{Array{Float64,1},1},Array{Float64,1},Array{Array{Array{Float64,1},1},1},OrdinaryDiffEq.RadauIIA5ConstantCache{DiffEqDiffTools.UDerivativeWrapper{ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},Float64,Float64},OrdinaryDiffEq.RadauIIA5Tableau{Float64,Float64},Float64,Float64,Array{Float64,1}}},DiffEqBase.DEStats},ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},OrdinaryDiffEq.RadauIIA5ConstantCache{DiffEqDiffTools.UDerivativeWrapper{ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},Float64,Float64},OrdinaryDiffEq.RadauIIA5Tableau{Float64,Float64},Float64,Float64,Array{Float64,1}},OrdinaryDiffEq.DEOptions{Float64,Float64,Float64,Float64,typeof(DiffEqBase.ODE_DEFAULT_NORM),typeof(LinearAlgebra.opnorm),CallbackSet{Tuple{},Tuple{}},typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN),typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE),typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK),DataStructures.BinaryHeap{Float64,DataStructures.LessThan},DataStructures.BinaryHeap{Float64,DataStructures.LessThan},Nothing,Nothing,Int64,Array{Float64,1},Array{Float64,1},Array{Float64,1}},Array{Float64,1},Float64,Nothing}) at /home/kanav/.julia/dev/OrdinaryDiffEq/src/solve.jl:353
[5] #__solve#380(::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::Function, ::ODEProblem{Array{Float64,1},Tuple{Float64,Float64},false,Float64,ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},Nothing,DiffEqBase.StandardODEProblem}, ::RadauIIA5{0,true,DiffEqBase.DefaultLinSolve,DataType,Nothing,Rational{Int64},Rational{Int64}}, ::Array{Any,1}, ::Array{Any,1}, ::Array{Any,1}, ::Type{Val{true}}) at /home/kanav/.julia/dev/OrdinaryDiffEq/src/solve.jl:7
[6] __solve at /home/kanav/.julia/dev/OrdinaryDiffEq/src/solve.jl:6 [inlined] (repeats 5 times)
[7] #solve#354 at /home/kanav/.julia/dev/DiffEqBase/src/solve.jl:39 [inlined]
[8] solve(::ODEProblem{Array{Float64,1},Tuple{Float64,Float64},false,Float64,ODEFunction{false,VanDerPol{getfield(Main, Symbol("##3#9")),getfield(Main, Symbol("##4#10")),getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Expr,Expr},LinearAlgebra.UniformScaling{Bool},Nothing,getfield(Main, Symbol("##5#11")),getfield(Main, Symbol("##4#10")),Nothing,getfield(Main, Symbol("##6#12")),getfield(Main, Symbol("##7#13")),getfield(Main, Symbol("##8#14")),Array{Symbol,1},Nothing},Nothing,DiffEqBase.StandardODEProblem}, ::RadauIIA5{0,true,DiffEqBase.DefaultLinSolve,DataType,Nothing,Rational{Int64},Rational{Int64}}) at /home/kanav/.julia/dev/DiffEqBase/src/solve.jl:27
[9] top-level scope at none:0
We have changed the FIRK test to not use the parameterized form (SciML/OrdinaryDiffEq.jl@4e9523f) so that it gets passed.
React
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
Django
The Web framework for perfectionists with deadlines.
Laravel
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
Facebook
We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft
Open source projects and samples from Microsoft.
Google
Google ❤️ Open Source for everyone.
Alibaba
Alibaba Open Source for everyone
D3
Data-Driven Documents codes.
Tencent
China tencent open source team.