There are a few @refs that need to get fixed up that are scattered around. A list comes from the Travis output:

 !! Unable to parse the reference '[`Common Solver Options`](@ref)'. [src/basics/integrator.md]
 !! Unable to parse the reference '[`Event Handling and Callback Functions`](@ref)'. [src/basics/integrator.md]
 !! Unable to parse the reference '[`Integrator Interface`](@ref)'. [src/features/callback_functions.md]
 !! Unable to parse the reference '[`Integrator Interface`](@ref)'. [src/features/callback_functions.md]
 !! Unable to parse the reference '[`Integrator Interface`](@ref)'. [src/features/callback_functions.md]
 !! Unable to parse the reference '[`Integrator Interface`](@ref)'. [src/solvers/ode_solve.md]

A few links in the basics/overview.html page are broken due to an extra "basics/" in the URL. For example, in the "Solving the Problems" subsection of ,http://docs.juliadiffeq.org/latest/basics/overview.html, the "common solver options manual page" link points to http://docs.juliadiffeq.org/latest/basics/basics/common_solver_opts.html, where it should point to http://docs.juliadiffeq.org/latest/basics/common_solver_opts.html. Similarly for "solution handling manual page" in the "Analyzing the Solution" subsection.

The relevant Markdown for the first example is line 49 of master/docs/src/basics/overview.md

arguments which are accepted by most methods is defined in [the common solver options manual page](common_solver_opts.html).

so it must be some issue in Markdown resolving relative links.

Hi I just installed your package, it looks great. When trying to execute the first beginner example here, it starts to precompile and ends with this unfortunately:

ERROR: LoadError: LoadError: LoadError: UndefVarError: @pack not defined
Stacktrace:
 [1] top-level scope
 [2] include at ./boot.jl:317 [inlined]
 [3] include_relative(::Module, ::String) at ./loading.jl:1038
 [4] include at ./sysimg.jl:29 [inlined]
 [5] include(::String) at /home/jprob/.julia/packages/OrdinaryDiffEq/c746g/src/OrdinaryDiffEq.jl:1
 [6] top-level scope at none:0
 [7] include at ./boot.jl:317 [inlined]
 [8] include_relative(::Module, ::String) at ./loading.jl:1038
 [9] include(::Module, ::String) at ./sysimg.jl:29
 [10] top-level scope at none:2
 [11] eval at ./boot.jl:319 [inlined]
 [12] eval(::Expr) at ./client.jl:389
 [13] top-level scope at ./none:3
in expression starting at /home/jprob/.julia/packages/OrdinaryDiffEq/c746g/src/perform_step/exponential_rk_perform_step.jl:1434
in expression starting at /home/jprob/.julia/packages/OrdinaryDiffEq/c746g/src/perform_step/exponential_rk_perform_step.jl:1416
in expression starting at /home/jprob/.julia/packages/OrdinaryDiffEq/c746g/src/OrdinaryDiffEq.jl:98
ERROR: LoadError: Failed to precompile OrdinaryDiffEq [1dea7af3-3e70-54e6-95c3-0bf5283fa5ed] to /home/jprob/.julia/compiled/v1.0/OrdinaryDiffEq/DlSvy.ji.
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] macro expansion at ./logging.jl:313 [inlined]
 [3] compilecache(::Base.PkgId, ::String) at ./loading.jl:1184
 [4] _require(::Base.PkgId) at ./logging.jl:311
 [5] require(::Base.PkgId) at ./loading.jl:852
 [6] macro expansion at ./logging.jl:311 [inlined]
 [7] require(::Module, ::Symbol) at ./loading.jl:834
 [8] include at ./boot.jl:317 [inlined]
 [9] include_relative(::Module, ::String) at ./loading.jl:1038
 [10] include(::Module, ::String) at ./sysimg.jl:29
 [11] top-level scope at none:2
 [12] eval at ./boot.jl:319 [inlined]
 [13] eval(::Expr) at ./client.jl:389
 [14] top-level scope at ./none:3
in expression starting at /home/jprob/.julia/packages/DiffEqCallbacks/dspKw/src/DiffEqCallbacks.jl:9
ERROR: LoadError: Failed to precompile DiffEqCallbacks [459566f4-90b8-5000-8ac3-15dfb0a30def] to /home/jprob/.julia/compiled/v1.0/DiffEqCallbacks/TKs5l.ji.
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] macro expansion at ./logging.jl:313 [inlined]
 [3] compilecache(::Base.PkgId, ::String) at ./loading.jl:1184
 [4] _require(::Base.PkgId) at ./logging.jl:311
 [5] require(::Base.PkgId) at ./loading.jl:852
 [6] macro expansion at ./logging.jl:311 [inlined]
 [7] require(::Module, ::Symbol) at ./loading.jl:834
 [8] include at ./boot.jl:317 [inlined]
 [9] include_relative(::Module, ::String) at ./loading.jl:1038
 [10] include(::Module, ::String) at ./sysimg.jl:29
 [11] top-level scope at none:2
 [12] eval at ./boot.jl:319 [inlined]
 [13] eval(::Expr) at ./client.jl:389
 [14] top-level scope at ./none:3
in expression starting at /home/jprob/.julia/packages/SteadyStateDiffEq/53QkP/src/SteadyStateDiffEq.jl:8
ERROR: LoadError: Failed to precompile SteadyStateDiffEq [9672c7b4-1e72-59bd-8a11-6ac3964bc41f] to /home/jprob/.julia/compiled/v1.0/SteadyStateDiffEq/lsCSw.ji.
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] macro expansion at ./logging.jl:313 [inlined]
 [3] compilecache(::Base.PkgId, ::String) at ./loading.jl:1184
 [4] _require(::Base.PkgId) at ./logging.jl:311
 [5] require(::Base.PkgId) at ./loading.jl:852
 [6] macro expansion at ./logging.jl:311 [inlined]
 [7] require(::Module, ::Symbol) at ./loading.jl:834
 [8] include at ./boot.jl:317 [inlined]
 [9] include_relative(::Module, ::String) at ./loading.jl:1038
 [10] include(::Module, ::String) at ./sysimg.jl:29
 [11] top-level scope at none:2
 [12] eval at ./boot.jl:319 [inlined]
 [13] eval(::Expr) at ./client.jl:389
 [14] top-level scope at ./none:3
in expression starting at /home/jprob/.julia/packages/DifferentialEquations/9VjqD/src/DifferentialEquations.jl:12
ERROR: LoadError: Failed to precompile DifferentialEquations [0c46a032-eb83-5123-abaf-570d42b7fbaa] to /home/jprob/.julia/compiled/v1.0/DifferentialEquations/UQdwS.ji.
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] macro expansion at ./logging.jl:313 [inlined]
 [3] compilecache(::Base.PkgId, ::String) at ./loading.jl:1184
 [4] macro expansion at ./logging.jl:311 [inlined]
 [5] _require(::Base.PkgId) at ./loading.jl:941
 [6] require(::Base.PkgId) at ./loading.jl:852
 [7] macro expansion at ./logging.jl:311 [inlined]
 [8] require(::Module, ::Symbol) at ./loading.jl:834
 [9] include_string(::Module, ::String, ::String) at ./loading.jl:1002
 [10] (::getfield(Atom, Symbol("##120#125")){String,String,Module})() at /home/jprob/.julia/packages/Atom/Pab0Z/src/eval.jl:120
 [11] withpath(::getfield(Atom, Symbol("##120#125")){String,String,Module}, ::String) at /home/jprob/.julia/packages/CodeTools/8CjYJ/src/utils.jl:30
 [12] withpath at /home/jprob/.julia/packages/Atom/Pab0Z/src/eval.jl:46 [inlined]
 [13] #119 at /home/jprob/.julia/packages/Atom/Pab0Z/src/eval.jl:117 [inlined]
 [14] hideprompt(::getfield(Atom, Symbol("##119#124")){String,String,Module}) at /home/jprob/.julia/packages/Atom/Pab0Z/src/repl.jl:76
 [15] macro expansion at /home/jprob/.julia/packages/Atom/Pab0Z/src/eval.jl:116 [inlined]
 [16] (::getfield(Atom, Symbol("##118#123")){Dict{String,Any}})() at ./task.jl:85

@onoderat docs are needed on the SDE solvers page for PCE and the definition of gg'

The docs should be updated to reflect that the mass_matrix keyword moved from ODEProblem constructors to ODEFunction constructors.
see http://docs.juliadiffeq.org/latest/types/ode_types.html#Constructors-1

On Julia 0.6.3-pre.0, defining the SIR model as indicated in the tutorial yields

ERROR: ArgumentError: Second argument must be of Symbol type

which disappears when I is changed into something else which does not already have a meaning in Julia.

In the JuliaDiffEq ecosystem, can you please indicate which plotting module and commands were used to produce paramest_notfit.png and paramest_fit.png?

It is fine to publish the .png in the .md files but it would be good for users to be able to produce their own plots. Using Plots; plotly() or gr() do not produce the same published graph.

Thanks.

I have compiled Julia 1.0 from source and it seems it works.
My system is OpenSuse Leap 15.

Then in pkg I'm trying to add DifferentialEquations.
The result is that I get
Error: Error building RandomNumbers:
│ ERROR: LoadError: LoadError: UndefVarError: is_bsd not defined
│ Stacktrace:
│ [1] build() at /home/prince/.julia/packages/RandomNumbers/5tfiq/deps/Random123/build.jl:16
│ [2] top-level scope at /home/prince/.julia/packages/RandomNumbers/5tfiq/deps/Random123/build.jl:40
│ [3] include at ./boot.jl:317 [inlined]
│ [4] include_relative(::Module, ::String) at ./loading.jl:1038
│ [5] include(::Module, ::String) at ./sysimg.jl:29
│ [6] include(::String) at ./client.jl:388
│ [7] top-level scope at none:0
│ [8] include at ./boot.jl:317 [inlined]
│ [9] include_relative(::Module, ::String) at ./loading.jl:1038
│ [10] include(::Module, ::String) at ./sysimg.jl:29
│ [11] include(::String) at ./client.jl:388
│ [12] top-level scope at none:0
│ in expression starting at /home/prince/.julia/packages/RandomNumbers/5tfiq/deps/Random123/build.jl:39
│ in expression starting at /home/prince/.julia/packages/RandomNumbers/5tfiq/deps/build.jl:1
└ @ Pkg.Operations ~/MYDISTR/JULIA/julia/usr/share/julia/stdlib/v1.0/Pkg/src/Operations.jl:1068
the command status in pkg gives:
[0c46a032] DifferentialEquations v5.2.0
but then the command "using DifferentialEquations" gives after some warnings "could not import..."
I get
ERROR: LoadError: LoadError: UndefVarError: start not defined
Stacktrace:
[1] getproperty(::Module, ::Symbol) at ./sysimg.jl:13
[2] top-level scope at none:0
[3] include at ./boot.jl:317 [inlined]
[4] include_relative(::Module, ::String) at ./loading.jl:1038
[5] include at ./sysimg.jl:29 [inlined]
[6] include(::String) at /home/prince/.julia/packages/MultiScaleArrays/lIdOy/src/MultiScaleArrays.jl:3
[7] top-level scope at none:0
[8] include at ./boot.jl:317 [inlined]
[9] include_relative(::Module, ::String) at ./loading.jl:1038
[10] include(::Module, ::String) at ./sysimg.jl:29
[11] top-level scope at none:2
[12] eval at ./boot.jl:319 [inlined]
[13] eval(::Expr) at ./client.jl:389
[14] top-level scope at ./none:3
in expression starting at /home/prince/.julia/packages/MultiScaleArrays/lIdOy/src/level_iterations.jl:8
in expression starting at /home/prince/.julia/packages/MultiScaleArrays/lIdOy/src/MultiScaleArrays.jl:26
ERROR: LoadError: Failed to precompile MultiScaleArrays [f9640e96-87f6-5992-9c3b-0743c6a49ffa] to /home/prince/.julia/compiled/v1.0/MultiScaleArrays/XBvBT.ji.
Stacktrace:
[1] error(::String) at ./error.jl:33
[2] macro expansion at ./logging.jl:313 [inlined]
[3] compilecache(::Base.PkgId, ::String) at ./loading.jl:1184
[4] _require(::Base.PkgId) at ./logging.jl:311
[5] require(::Base.PkgId) at ./loading.jl:852
[6] macro expansion at ./logging.jl:311 [inlined]
[7] require(::Module, ::Symbol) at ./loading.jl:834
[8] include at ./boot.jl:317 [inlined]
[9] include_relative(::Module, ::String) at ./loading.jl:1038
[10] include(::Module, ::String) at ./sysimg.jl:29
[11] top-level scope at none:2
[12] eval at ./boot.jl:319 [inlined]
[13] eval(::Expr) at ./client.jl:389
[14] top-level scope at ./none:3
in expression starting at /home/prince/.julia/packages/DifferentialEquations/GvSKB/src/DifferentialEquations.jl:29
ERROR: Failed to precompile DifferentialEquations [0c46a032-eb83-5123-abaf-570d42b7fbaa] to /home/prince/.julia/compiled/v1.0/DifferentialEquations/UQdwS.ji.
Stacktrace:
[1] error(::String) at ./error.jl:33
[2] macro expansion at ./logging.jl:313 [inlined]
[3] compilecache(::Base.PkgId, ::String) at ./loading.jl:1184
[4] _require(::Base.PkgId) at ./logging.jl:311
[5] require(::Base.PkgId) at ./loading.jl:852
[6] macro expansion at ./logging.jl:311 [inlined]
[7] require(::Module, ::Symbol) at ./loading.jl:834

It would be nice if the Bayesian doc examples showed how to plot the chains, have plot in the docs of what this all looks like, and discusses how to read the diagnostics.

The documentation of the @ode_def macro should include that the independent variable can be addressed via t for the sake of non-autonomous ODEs.
Also a short of example of how to provide a derivative of a user defined function would be good.
Finally a paragraph ( or section? ) about limits of the macro ( e.g. can't handle branching ) should be added.

@devmotion should get these added to the callback library page.

The DynamicalODEProblem types all have sufficient documentation of their definition and solvers now. However, there's things which are missing:

• A tutorial on dynamical ODEs, showing how to define them, the differences between non-symplectic and symplectic methods, and showing how to use the ArrayPartition
• A description of the NBodyProblem with an example in the Physical Models page.

@YingboMa would you like to contribute these pages?

This is embarrassing. Wrote in the wrong place. Sorry. Remove please?

This example is running fine. Can you extend the example to all four parameters to be estimated instead of just a=>. It should be b=>, c=>, d=> but it does not run further down.

Further down, using optim. This is going to be an extremely useful step for testing different optimization methods. What is the proper syntax for introducing autodiff? It should be:

BFGS(), OptimizationOptions(autodiff = true) or
Newton(), OptimizationOptions(autodiff = true)

but I cannot get it to work.

Finally, running result = optimize(cost_function, [1.02], BFGS()) gives the following warning:
WARNING: Interrupted. Larger maxiters is needed.
WARNING: Interrupted. Larger maxiters is needed.
WARNING: Interrupted. Larger maxiters is needed.
WARNING: Interrupted. Larger maxiters is needed.
WARNING: Interrupted. Larger maxiters is needed.
WARNING: Interrupted. Larger maxiters is needed.
WARNING: Interrupted. Larger maxiters is needed.
WARNING: Interrupted. Larger maxiters is needed.
WARNING: Interrupted. Larger maxiters is needed.

Where are the parameter twitches for these?

Otherwise, excellent work to focus on effectiveness on the key steps.

@tkf where should it go?

https://discourse.julialang.org/t/handling-instability-when-solving-ode-problems/9019/5?u=chrisrackauckas

I am using Julia Version 0.6.0 (2017-06-19 13:05 UTC) on ubuntu, and
After running Pkg.update(), I get errors when I run using DifferentialEquations
Thanks for you help,
cheers

julia> using DifferentialEquations
INFO: Precompiling module DifferentialEquations.
WARNING: Method definition midpoints(Base.Range{T} where T) in module Base at deprecated.jl:56 overwritten in module StatsBase at /home/hmh/.julia/v0.6/StatsBase/src/hist.jl:535.
WARNING: Method definition midpoints(AbstractArray{T, 1} where T) in module Base at deprecated.jl:56 overwritten in module StatsBase at /home/hmh/.julia/v0.6/StatsBase/src/hist.jl:533.                                                                               
**ERROR: LoadError: LoadError: UndefVarError: AbstractPoissonFEMAlgorithm not defined**                                                                                                                                                                                    
Stacktrace:                                                                                                                                                                                                                                                            
 [1] include_from_node1(::String) at ./loading.jl:569                                                                                                                                                                                                                  
 [2] include(::String) at ./sysimg.jl:14                                                                                                                                                                                                                               
 [3] include_from_node1(::String) at ./loading.jl:569                                                                                                                                                                                                                  
 [4] include(::String) at ./sysimg.jl:14                                                                                                                                                                                                                               
 [5] anonymous at ./<missing>:2                                                                                                                                                                                                                                        
while loading /home/hmh/.julia/v0.6/FiniteElementDiffEq/src/algorithms.jl, in expression starting on line 1                                                                                                                                                            
while loading /home/hmh/.julia/v0.6/FiniteElementDiffEq/src/FiniteElementDiffEq.jl, in expression starting on line 12                                                                                                                                                  
**ERROR: LoadError: Failed to precompile FiniteElementDiffEq to /home/hmh/.julia/lib/v0.6/FiniteElementDiffEq.ji.**                                                                                                                                                        
Stacktrace:                                                                                                                                                                                                                                                            
 [1] compilecache(::String) at ./loading.jl:703                                                                                                                                                                                                                        
 [2] _require(::Symbol) at ./loading.jl:456                                                                                                                                                                                                                            
 [3] require(::Symbol) at ./loading.jl:398                                                                                                                                                                                                                             
 [4] include_from_node1(::String) at ./loading.jl:569                                                                                                                                                                                                                  
 [5] include(::String) at ./sysimg.jl:14                                                                                                                                                                                                                               
 [6] anonymous at ./<missing>:2                                                                                                                                                                                                                                        
while loading /home/hmh/.julia/v0.6/DifferentialEquations/src/DifferentialEquations.jl, in expression starting on line 14                                                                                                                                              
**ERROR: Failed to precompile DifferentialEquations to /home/hmh/.julia/lib/v0.6/DifferentialEquations.ji.**                                                                                                                                                               
Stacktrace:                                                                                                                                                                                                                                                            
 [1] compilecache(::String) at ./loading.jl:703                                                                                                                                                                                                                        
 [2] _require(::Symbol) at ./loading.jl:490                                                                                                                                                                                                                            
 [3] require(::Symbol) at ./loading.jl:398

@YingboMa

It's a good way to show how to use tstops with DiscreteCallback together. @ronisbr

@tkf noticed this.

Should add these new methods to the docs.

https://github.com/JuliaDiffEq/DiffEqDocs.jl/blob/master/docs/src/solvers/ode_solve.md

@ranocha

From the ODE problem types page:

using DiffEqProblemLibrary
prob = prob_ode_linear
sol = solve(prob)

doesn't seem to work anymore. This, and the related SDE/DAE examples, need to be updated for the new submodule form of DiffEqProblemLibrary.

The last call to use solver Vern7 instead of Tsit5 with Lorenz:

tspan = (0.0,40.0)
prob = ODEProblem(g,u0,tspan)
cb = AdaptiveProbIntsUncertainty(7)
monte_prob = MonteCarloProblem(prob)
sim = solve(monte_prob,Vern7(),num_monte=100,callback=cb,reltol=1e-6)
using Plots; plotly(); plot(sim,vars=(0,1),linealpha=0.4)

gives:

MethodError: no method matching getindex(::Void, ::Int64)

Stacktrace:
[1] #573 at .\asyncmap.jl:178 [inlined]
[2] foreach(::Base.##573#575, ::Array{Any,1}) at .\abstractarray.jl:1733
[3] maptwice(::Function, ::Channel{Any}, ::Array{Any,1}, ::UnitRange{Int64}, ::Vararg{UnitRange{Int64},N} where N) at .\asyncmap.jl:178
[4] wrap_n_exec_twice(::Channel{Any}, ::Array{Any,1}, ::Base.Distributed.##204#207{CachingPool}, ::Function, ::UnitRange{Int64}, ::Vararg{UnitRange{Int64},N} where N) at .\asyncmap.jl:154
[5] #async_usemap#558(::Function, ::Void, ::Function, ::DiffEqMonteCarlo.##4#7{DiffEqBase.MonteCarloProblem{DiffEqBase.ODEProblem{Array{Float64,1},Float64,true,Void,LorenzExample,Void,Void,UniformScaling{Int64},DiffEqBase.StandardODEProblem},DiffEqBase.##238#251,DiffEqBase.##237#250,DiffEqBase.##239#252,Array{Any,1}},OrdinaryDiffEq.Vern7,Tuple{Tuple{Symbol,DiffEqBase.DiscreteCallback{DiffEqUncertainty.##3#4,DiffEqUncertainty.AdaptiveProbIntsCache,DiffEqBase.#INITIALIZE_DEFAULT}},Tuple{Symbol,Float64}}}, ::UnitRange{Int64}, ::Vararg{UnitRange{Int64},N} where N) at .\asyncmap.jl:103
[6] (::Base.#kw##async_usemap)(::Array{Any,1}, ::Base.#async_usemap, ::Function, ::UnitRange{Int64}, ::Vararg{UnitRange{Int64},N} where N) at .<missing>:0
[7] (::Base.#kw##asyncmap)(::Array{Any,1}, ::Base.#asyncmap, ::Function, ::UnitRange{Int64}) at .<missing>:0
[8] #pmap#203(::Bool, ::Int64, ::Void, ::Array{Any,1}, ::Void, ::Function, ::CachingPool, ::Function, ::UnitRange{Int64}) at .\distributed\pmap.jl:126
[9] (::Base.Distributed.#kw##pmap)(::Array{Any,1}, ::Base.Distributed.#pmap, ::CachingPool, ::Function, ::UnitRange{Int64}) at .<missing>:0
[10] solve_batch(::DiffEqBase.MonteCarloProblem{DiffEqBase.ODEProblem{Array{Float64,1},Float64,true,Void,LorenzExample,Void,Void,UniformScaling{Int64},DiffEqBase.StandardODEProblem},DiffEqBase.##238#251,DiffEqBase.##237#250,DiffEqBase.##239#252,Array{Any,1}}, ::OrdinaryDiffEq.Vern7, ::Symbol, ::UnitRange{Int64}, ::Int64, ::Tuple{Symbol,DiffEqBase.DiscreteCallback{DiffEqUncertainty.##3#4,DiffEqUncertainty.AdaptiveProbIntsCache,DiffEqBase.#INITIALIZE_DEFAULT}}, ::Vararg{Any,N} where N) at C:\Users\Denis.julia\v0.6\DiffEqMonteCarlo\src\solve.jl:44
[11] macro expansion at C:\Users\Denis.julia\v0.6\DiffEqMonteCarlo\src\solve.jl:28 [inlined]
[12] macro expansion at .\util.jl:293 [inlined]
[13] #solve#1(::Int64, ::Int64, ::Int64, ::Symbol, ::Array{Any,1}, ::Function, ::DiffEqBase.MonteCarloProblem{DiffEqBase.ODEProblem{Array{Float64,1},Float64,true,Void,LorenzExample,Void,Void,UniformScaling{Int64},DiffEqBase.StandardODEProblem},DiffEqBase.##238#251,DiffEqBase.##237#250,DiffEqBase.##239#252,Array{Any,1}}, ::OrdinaryDiffEq.Vern7, ::Type{Val{true}}) at C:\Users\Denis.julia\v0.6\DiffEqMonteCarlo\src\solve.jl:22
[14] (::DiffEqBase.#kw##solve)(::Array{Any,1}, ::DiffEqBase.#solve, ::DiffEqBase.MonteCarloProblem{DiffEqBase.ODEProblem{Array{Float64,1},Float64,true,Void,LorenzExample,Void,Void,UniformScaling{Int64},DiffEqBase.StandardODEProblem},DiffEqBase.##238#251,DiffEqBase.##237#250,DiffEqBase.##239#252,Array{Any,1}}, ::OrdinaryDiffEq.Vern7, ::Type{Val{true}}) at .<missing>:0 (repeats 2 times)
[15] include_string(::String, ::String) at .\loading.jl:522

In section http://docs.juliadiffeq.org/stable/analysis/parameter_estimation.html#The-Loss-Function-1 it says there is a convenience method:

L2DistLoss(t,data;weight=nothing)

But it does not exists. Consequently the examples using this function do not work either:
http://docs.juliadiffeq.org/stable/analysis/parameter_estimation.html#Local-Optimization-Examples-1

@MSeeker1340

Since programatically g has to be written in matrix form, it would be good to document what commutative noise and bbprime are in this notation as well.

@onoderat

https://github.com/JuliaDiffEq/DiffEqDocs.jl/blob/master/docs/src/features/diffeq_arrays.md#example-dynamics-equations

I copied it exactly and ran it in a new Julia session and got an error:

ERROR: LoadError: Unitful.DimensionError(Unitful.FreeUnits{(Unitful.Unit{:Meter,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1),)}}(3, 1//1), Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, -1//1)),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Time}(-1//1))}}(), Quantity{Float64,Unitful.Dimensions{()},Unitful.FreeUnits{(),Unitful.Dimensions{()}}}(0.0))

Here, we will start with 999 susceptible people, 1 infected person, and 0 recovered people

This line justifies the initial value [999, 1, 0] but just from the docs it is unclear to me why the variable are ordered this way. Is it the order where they appear in the model?

Currently the docs give simply example that use the style:

name = function (args)
  foo
end

instead of the more idiomatic

function name(args)
  foo
end

which is likely to seem strange to regular end users of the package. Once 0.6 is standard and Julia#265 is fixed the later version will likely be better from a pedagogical point of view.

@Vaibhavdixit02

Hi,

I just wanted to do the ode_example tutorial and encountered the following problem:
When I tried to execute sol = solve(prob), julia threw the following errors:

MethodError: no method matching solve(::DiffEqBase.ODEProblem{Float64,Float64,false,#f})
Closest candidates are:
  solve{uType,tType,isinplace,T<:OrdinaryDiffEq.OrdinaryDiffEqAlgorithm,F}(::DiffEqBase.AbstractODEProblem{uType,tType,isinplace,F}, ::T<:OrdinaryDiffEq.OrdinaryDiffEqAlgorithm) at C:\Users\thiem\.julia\v0.5\OrdinaryDiffEq\src\solve.jl:20
  solve{uType,tType,isinplace,T<:OrdinaryDiffEq.OrdinaryDiffEqAlgorithm,F}(::DiffEqBase.AbstractODEProblem{uType,tType,isinplace,F}, ::T<:OrdinaryDiffEq.OrdinaryDiffEqAlgorithm, ::Any) at C:\Users\thiem\.julia\v0.5\OrdinaryDiffEq\src\solve.jl:20
  solve{uType,tType,isinplace,T<:OrdinaryDiffEq.OrdinaryDiffEqAlgorithm,F}(::DiffEqBase.AbstractODEProblem{uType,tType,isinplace,F}, ::T<:OrdinaryDiffEq.OrdinaryDiffEqAlgorithm, ::Any, ::Any) at C:\Users\thiem\.julia\v0.5\OrdinaryDiffEq\src\solve.jl:20

It seems that there is no solve function which can choose its solving algorthm by itself. If I try the next line
sol = solve(prob,Euler(),dt=1/2^4) everything works fine. Has there been a change in the API, that has not been reflected in the tutorial?

Replacating the Lotka Volterra estimation for the Lorentz example:

g = @ode_def LorenzExample begin
#g = @ode_def_nohes LorenzExample begin
dx = σ*(y-x)
dy = x*(ρ-z) - y
dz = xy - βz
end σ=>10.0 ρ=>28.0 β=(8/3)

u0 = [1.0;0.0;0.0]
tspan = (0.0,1.0)
prob = ODEProblem(g,u0,tspan)

What is the correct syntax for generating the same data as PODES (span 0 to 30 with 500 data points)?

sol = solve(prob,Tsit5())
t = collect(linspace(0,30,500))
randomized = [(sol(t[i]) + .01randn(2)) for i in 1:length(t)]

Could not remember any docs about data generation.

This needs to be added to the docs @elevien

This is embarrassing. Wrote in the wrong place. Remove please?

1. Type specification. uType, tType, and things like prototype types (noise_rate_prototype, jac_prototype, etc.) and parameters all come from the passed values. These can be any type. Example of a struct for parameters?
2. Type-equivalencies (SplitODEProblem -> ODEProblem with a SplitFunction)? Or is this an implementation detail?
3. isinplace and setting inplace.

@sipah00

https://travis-ci.org/JuliaDiffEq/DiffEqDocs.jl/jobs/432562826#L611-L711

It should be very easy to know how to credit the appropriate authors. This is a little bit more difficult than normal since the interface is distributed, but there should be one doc page for this. Since I will have a few publications on the methods in this ecosystem soon, I'll at least get around to it by then. However, even "non-paper contributions" should be mentioned. For example, if one is using the algorithms of ODE.jl, attribution should go to like @mauro3 or @pwl, whereas for Sundials algorithms attribution should cite the Sundials paper.

In the forthcoming parameter estimation notebook, the idea is to give in the md text the menu of options for each module used to build the optimization problem. For LeastSquaresOptim, this is simple with just a few clarifications that I requested from Matthieu Gomez.

For Optim, this proves more difficult and I cannot sort out what is linked to Optim and what is linked to build_optim_objective. In short, look at this:

result = optimize(cost_function, [1.02], LBFGS()) #Working
#result = optimize(cost_function, [1.02], LBFGS(), Optim.Options(autodiff = use_autodiff))
#result = optimize(cost_function, [1.02], Optim.Options(autodiff = true)) #not working
#result = optimize(cost_function, [1.02], BFGS(), Optim.Options(autodiff = use_autodiff)) #not working
#result = optimize(cost_function, [1.02], Newton(), Optim.Options(autodiff = true)) # not working

My aim is to have a simple menu of methods: Brent, Newton, BFGS, LBFGS etc... and a simple menu of options for each menu. All of this working 100 percent of the time, otherwise we should get a flag saying that the combination is not appropriate.

The paragraph on the problem generator function,
https://github.com/JuliaDiffEq/DiffEqDocs.jl/blob/b11c9da2bdb6c3c7f9ca8152a62eb977b014987f/docs/src/analysis/parameter_estimation.md#the-problem-generator-function
doesn't reflect the current state of the code.
https://github.com/JuliaDiffEq/DiffEqBase.jl/blob/0d5277939e027bfa1962ae0c3bde8cc275b1a480/src/parameters_interface.jl#L1
Most importantly, there's no wrapping of f now that parameters are passed around explicitly.

https://docs.julialang.org/en/stable/manual/style-guide/#Append-!-to-names-of-functions-that-modify-their-arguments-1

Not a ton of benefit here, I think, but I did just manage to confuse myself reading an example because I forgot that a function modified out rather than returning dy. Would be good to switch everything over to following that part of the style guide eventually.

Then again, many of these functions are called simply "f" and are treated more or less as anonymous functions. There seems to be a strong convention throughout a lot of tutorials/docs to call those kind of functions "f" rather than "f!". I don't personally think this is a good convention but would understand if that's the direction chosen.

@YingboMa, change the previous documentation of the nonlinear solvers to be on your new format. Add NLAnderson in there but mark it as "In development"

ParameterizedFunctions are getting a more in-depth interface, and it needs to start getting documented