Coder Social home page Coder Social logo

sciml / scimltutorials.jl Goto Github PK

View Code? Open in Web Editor NEW
710.0 25.0 129.0 222.08 MB

Tutorials for doing scientific machine learning (SciML) and high-performance differential equation solving with open source software.

Home Page: https://tutorials.sciml.ai

License: Other

Julia 21.56% Smarty 10.34% CSS 54.26% Shell 13.84%
differentialequations differential-equations ode sde dae dde ordinary-differential-equations neural-differential-equations neural-ode pde partial-differential-equations stochastic-differential-equations julia scientific-machine-learning sciml python r hacktoberfest

scimltutorials.jl's Introduction

SciMLTutorials.jl: Tutorials for Scientific Machine Learning and Differential Equations

Join the chat at https://julialang.zulipchat.com #sciml-bridged Stable Global Docs

Build status

ColPrac: Contributor's Guide on Collaborative Practices for Community Packages SciML Code Style

SciMLTutorials.jl holds PDFs, webpages, and interactive Jupyter notebooks showing how to utilize the software in the SciML Scientific Machine Learning ecosystem. This set of tutorials was made to complement the documentation and the devdocs by providing practical examples of the concepts. For more details, please consult the docs.

Note: this library has been deprecated and its tutorials have been moved to the repos of the respective packages. It may be revived in the future if there is a need for longer-form tutorials!

Results

To view the SciML Tutorials, go to tutorials.sciml.ai. By default, this will lead to the latest tagged version of the tutorials. To see the in-development version of the tutorials, go to https://tutorials.sciml.ai/dev/.

Static outputs in pdf, markdown, and html reside in SciMLTutorialsOutput.

Video Tutorial

Video Tutorial

Interactive Notebooks

To generate the interactive notebooks, first install the SciMLTutorials, instantiate the environment, and then run SciMLTutorials.open_notebooks(). This looks as follows:

]add SciMLTutorials#master
]activate SciMLTutorials
]instantiate
using SciMLTutorials
SciMLTutorials.open_notebooks()

The tutorials will be generated at your pwd() in a folder called generated_notebooks.

Note that when running the tutorials, the packages are not automatically added. Thus you will need to add the packages manually or use the internal Project/Manifest tomls to instantiate the correct packages. This can be done by activating the folder of the tutorials. For example,

using Pkg
Pkg.activate(joinpath(pkgdir(SciMLTutorials),"tutorials","models"))
Pkg.instantiate()

will add all of the packages required to run any tutorial in the models folder.

Contributing

All of the files are generated from the Weave.jl files in the tutorials folder. The generation process runs automatically, and thus one does not necessarily need to test the Weave process locally. Instead, simply open a PR that adds/updates a file in the "tutorials" folder and the PR will generate the tutorial on demand. Its artifacts can then be inspected in the Buildkite as described below before merging. Note that it will use the Project.toml and Manifest.toml of the subfolder, so any changes to dependencies requires that those are updated.

Reporting Bugs and Issues

Report any bugs or issues at the SciMLTutorials repository.

Inspecting Tutorial Results

To see tutorial results before merging, click into the BuildKite, click onto Artifacts, and then investigate the trained results.

Manually Generating Files

To run the generation process, do for example:

]activate SciMLTutorials # Get all of the packages
using SciMLTutorials
SciMLTutorials.weave_file(joinpath(pkgdir(SciMLTutorials),"tutorials","models"),"01-classical_physics.jmd")

To generate all of the files in a folder, for example, run:

SciMLTutorials.weave_folder(joinpath(pkgdir(SciMLTutorials),"tutorials","models"))

To generate all of the notebooks, do:

SciMLTutorials.weave_all()

Each of the tuturials displays the computer characteristics at the bottom of the benchmark.

scimltutorials.jl's People

Contributors

actions-user avatar arnostrouwen avatar ashutosh-b-b avatar asinghvi17 avatar charleskawczynski avatar chrisrackauckas avatar christopher-dg avatar dangirsh avatar danielmk avatar dependabot[bot] avatar devmotion avatar felixcremer avatar giordano avatar github-actions[bot] avatar goggle avatar isaacsas avatar maxcan-code avatar mikhail-vaganov avatar moelf avatar ranjanan avatar ranocha avatar ruibin-liu avatar sebastianm-c avatar shahriariravanian avatar staticfloat avatar thazhemadam avatar vaibhavdixit02 avatar viralbshah avatar xorjane avatar yingboma avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

scimltutorials.jl's Issues

SparsityDetection bug in 02_advanced_ODE_solving notebook

Running:

using SparsityDetection, SparseArrays
input = rand(32,32,2)
output = similar(input)
sparsity_pattern = sparsity!(brusselator_2d_loop,output,input,p,0.0)
jac_sparsity = Float64.(sparse(sparsity_pattern))

throws the following error:

┌ Info: Precompiling SparsityDetection [684fba80-ace3-11e9-3d08-3bc7ed6f96df]
└ @ Base loading.jl:1260
MethodError: no method matching iterate(::Tuple{DataType,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}}, ::Tuple{DataType,Int64})
Closest candidates are:
iterate(!Matched::Core.SimpleVector, ::Any) at essentials.jl:603
iterate(!Matched::ExponentialBackOff, ::Any) at error.jl:253
iterate(!Matched::Base.MethodList, ::Any...) at reflection.jl:854
...

Stacktrace:
[1] call at C:\Users\Denis.julia\packages\Cassette\7OymZ\src\context.jl:451 [inlined]
[2] fallback at C:\Users\Denis.julia\packages\Cassette\7OymZ\src\context.jl:448 [inlined]
[3] recurse(::Cassette.Context{SparsityDetection.var"##SparsityContext#Name",Tuple{Sparsity,SparsityDetection.Path},Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},SparsityDetection.var"##PassType#253",IdDict{Module,Dict{Symbol,Cassette.BindingMeta}},Cassette.DisableHooks}, ::typeof(iterate), ::Cassette.Tagged{Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},Tuple{DataType,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}},Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Tuple{Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},NamedTuple{(:ref, :step, :len, :offset),Tuple{Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},NamedTuple{(:hi, :lo),Tuple{Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}}}}}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},NamedTuple{(:hi, :lo),Tuple{Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}}}}}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}}}}}}},Cassette.Context{SparsityDetection.var"##SparsityContext#Name",Tuple{Sparsity,SparsityDetection.Path},Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},SparsityDetection.var"##PassType#253",IdDict{Module,Dict{Symbol,Cassette.BindingMeta}},Cassette.DisableHooks}}, ::Tuple{DataType,Int64}) at C:\Users\Denis.julia\packages\Cassette\7OymZ\src\overdub.jl:486
[4] overdub(::Cassette.Context{SparsityDetection.var"##SparsityContext#Name",Tuple{Sparsity,SparsityDetection.Path},Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},SparsityDetection.var"##PassType#253",IdDict{Module,Dict{Symbol,Cassette.BindingMeta}},Cassette.DisableHooks}, ::Function, ::Cassette.Tagged{Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},Tuple{DataType,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}},Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Tuple{Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},NamedTuple{(:ref, :step, :len, :offset),Tuple{Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},NamedTuple{(:hi, :lo),Tuple{Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}}}}}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},NamedTuple{(:hi, :lo),Tuple{Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}}}}}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}}}}}}},Cassette.Context{SparsityDetection.var"##SparsityContext#Name",Tuple{Sparsity,SparsityDetection.Path},Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},SparsityDetection.var"##PassType#253",IdDict{Module,Dict{Symbol,Cassette.BindingMeta}},Cassette.DisableHooks}}, ::Tuple{DataType,Int64}) at C:\Users\Denis.julia\packages\SparsityDetection\Q6Utm\src\sparsity_tracker.jl:134
[5] (::SparsityDetection.var"#8#9"{Cassette.Context{SparsityDetection.var"##SparsityContext#Name",Tuple{Sparsity,SparsityDetection.Path},Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},SparsityDetection.var"##PassType#253",IdDict{Module,Dict{Symbol,Cassette.BindingMeta}},Cassette.DisableHooks},typeof(iterate)})(::Cassette.Tagged{Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},Tuple{DataType,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}},Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Tuple{Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},NamedTuple{(:ref, :step, :len, :offset),Tuple{Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},NamedTuple{(:hi, :lo),Tuple{Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}}}}}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},NamedTuple{(:hi, :lo),Tuple{Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}}}}}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}}}}}}},Cassette.Context{SparsityDetection.var"##SparsityContext#Name",Tuple{Sparsity,SparsityDetection.Path},Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},SparsityDetection.var"##PassType#253",IdDict{Module,Dict{Symbol,Cassette.BindingMeta}},Cassette.DisableHooks}}, ::Vararg{Any,N} where N) at C:\Users\Denis.julia\packages\Cassette\7OymZ\src\context.jl:262
[6] overdub(::Cassette.Context{SparsityDetection.var"##SparsityContext#Name",Tuple{Sparsity,SparsityDetection.Path},Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},SparsityDetection.var"##PassType#253",IdDict{Module,Dict{Symbol,Cassette.BindingMeta}},Cassette.DisableHooks}, ::typeof(Core._apply_iterate), ::Function, ::Function, ::Cassette.Tagged{Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},Tuple{DataType,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}},Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Tuple{Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},NamedTuple{(:ref, :step, :len, :offset),Tuple{Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},NamedTuple{(:hi, :lo),Tuple{Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}}}}}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},NamedTuple{(:hi, :lo),Tuple{Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}}}}}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}},Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}}}}}}},Cassette.Context{SparsityDetection.var"##SparsityContext#Name",Tuple{Sparsity,SparsityDetection.Path},Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},SparsityDetection.var"##PassType#253",IdDict{Module,Dict{Symbol,Cassette.BindingMeta}},Cassette.DisableHooks}}, ::Tuple{Int64}) at C:\Users\Denis.julia\packages\Cassette\7OymZ\src\context.jl:262
[7] checkbounds at .\abstractarray.jl:502 [inlined]
[8] overdub at C:\Users\Denis.julia\packages\SparsityDetection\Q6Utm\src\sparsity_tracker.jl:134 [inlined]
[9] getindex at .\range.jl:641 [inlined]
[10] recurse(::Cassette.Context{SparsityDetection.var"##SparsityContext#Name",Tuple{Sparsity,SparsityDetection.Path},Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},SparsityDetection.var"##PassType#253",IdDict{Module,Dict{Symbol,Cassette.BindingMeta}},Cassette.DisableHooks}, ::typeof(getindex), ::StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}, ::Int64) at C:\Users\Denis.julia\packages\Cassette\7OymZ\src\overdub.jl:0
[11] overdub(::Cassette.Context{SparsityDetection.var"##SparsityContext#Name",Tuple{Sparsity,SparsityDetection.Path},Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},SparsityDetection.var"##PassType#253",IdDict{Module,Dict{Symbol,Cassette.BindingMeta}},Cassette.DisableHooks}, ::Function, ::StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}, ::Int64) at C:\Users\Denis.julia\packages\SparsityDetection\Q6Utm\src\sparsity_tracker.jl:134
[12] brusselator_2d_loop at .\In[11]:10 [inlined]
[13] recurse(::Cassette.Context{SparsityDetection.var"##SparsityContext#Name",Tuple{Sparsity,SparsityDetection.Path},Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},SparsityDetection.var"##PassType#253",IdDict{Module,Dict{Symbol,Cassette.BindingMeta}},Cassette.DisableHooks}, ::typeof(brusselator_2d_loop), ::Cassette.Tagged{Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},Array{Float64,3},Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Array{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta},3},Cassette.Context{SparsityDetection.var"##SparsityContext#Name",Tuple{Sparsity,SparsityDetection.Path},Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},SparsityDetection.var"##PassType#253",IdDict{Module,Dict{Symbol,Cassette.BindingMeta}},Cassette.DisableHooks}}, ::Cassette.Tagged{Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},Array{Float64,3},Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Array{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta},3},Cassette.Context{SparsityDetection.var"##SparsityContext#Name",Tuple{Sparsity,SparsityDetection.Path},Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},SparsityDetection.var"##PassType#253",IdDict{Module,Dict{Symbol,Cassette.BindingMeta}},Cassette.DisableHooks}}, ::Cassette.Tagged{Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},NTuple{4,Float64},Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},NTuple{4,Cassette.Immutable{Cassette.Meta{Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta}}},Cassette.Context{SparsityDetection.var"##SparsityContext#Name",Tuple{Sparsity,SparsityDetection.Path},Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},SparsityDetection.var"##PassType#253",IdDict{Module,Dict{Symbol,Cassette.BindingMeta}},Cassette.DisableHooks}}, ::Cassette.Tagged{Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},Float64,Union{SparsityDetection.Input, SparsityDetection.Output, SparsityDetection.ProvinanceSet},Cassette.NoMetaMeta,Cassette.Context{SparsityDetection.var"##SparsityContext#Name",Tuple{Sparsity,SparsityDetection.Path},Cassette.Tag{SparsityDetection.var"##SparsityContext#Name",0x4e07e39148336526,Nothing},SparsityDetection.var"##PassType#253",IdDict{Module,Dict{Symbol,Cassette.BindingMeta}},Cassette.DisableHooks}}) at C:\Users\Denis.julia\packages\Cassette\7OymZ\src\overdub.jl:0
[14] sparsity!(::Function, ::Array{Float64,3}, ::Array{Float64,3}, ::NTuple{4,Float64}, ::Vararg{Any,N} where N; sparsity::Sparsity, verbose::Bool) at C:\Users\Denis.julia\packages\SparsityDetection\Q6Utm\src\program_sparsity.jl:29
[15] sparsity!(::Function, ::Array{Float64,3}, ::Array{Float64,3}, ::NTuple{4,Float64}, ::Vararg{Any,N} where N) at C:\Users\Denis.julia\packages\SparsityDetection\Q6Utm\src\program_sparsity.jl:23
[16] top-level scope at In[12]:4

Example: DiffEq + Unitful broken

I'm trying to run the example here. Turns out it doesn't work on current release versions and Julia 1.0.

DimensionError: s and 0.06 are not dimensionally compatible.

Stacktrace:
 [1] convert(::Type{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}}}, ::Float64) at C:\Users\carsten\.julia\packages\Unitful\RG8e9\src\conversion.jl:93
 [2] ode_determine_initdt(::Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}}, ::Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}}, ::Float64, ::Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}}, ::Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}}, ::Float64, ::typeof(DiffEqBase.ODE_DEFAULT_NORM), ::ODEProblem{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}},Tuple{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}}},false,Nothing,ODEFunction{false,getfield(Main, Symbol("##7#8")),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Nothing,DiffEqBase.StandardODEProblem}, ::OrdinaryDiffEq.ODEIntegrator{Tsit5,Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}},Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},Nothing,Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(-1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, -1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(-1//1),)}}},Float64,Float64,Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-3//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1), Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, -1//1)),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-3//1))}}},1},ODESolution{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}},1,Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}},1},Nothing,Nothing,Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},1},Array{Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-3//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1), Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, -1//1)),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-3//1))}}},1},1},ODEProblem{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}},Tuple{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}}},false,Nothing,ODEFunction{false,getfield(Main, Symbol("##7#8")),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Nothing,DiffEqBase.StandardODEProblem},Tsit5,OrdinaryDiffEq.InterpolationData{ODEFunction{false,getfield(Main, Symbol("##7#8")),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}},1},Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},1},Array{Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-3//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1), Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, -1//1)),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-3//1))}}},1},1},OrdinaryDiffEq.Tsit5ConstantCache{Float64,Float64}}},ODEFunction{false,getfield(Main, Symbol("##7#8")),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},OrdinaryDiffEq.Tsit5ConstantCache{Float64,Float64},OrdinaryDiffEq.DEOptions{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}},Float64,Float64,Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},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{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},DataStructures.LessThan},DataStructures.BinaryHeap{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},DataStructures.LessThan},Nothing,Nothing,Int64,Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},1},Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},1},Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},1}},Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-3//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1), Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, -1//1)),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-3//1))}}}}) at C:\Users\carsten\.julia\packages\OrdinaryDiffEq\d47lJ\src\initdt.jl:138
 [3] auto_dt_reset!(::OrdinaryDiffEq.ODEIntegrator{Tsit5,Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}},Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},Nothing,Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(-1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, -1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(-1//1),)}}},Float64,Float64,Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-3//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1), Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, -1//1)),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-3//1))}}},1},ODESolution{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}},1,Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}},1},Nothing,Nothing,Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},1},Array{Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-3//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1), Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, -1//1)),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-3//1))}}},1},1},ODEProblem{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}},Tuple{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}}},false,Nothing,ODEFunction{false,getfield(Main, Symbol("##7#8")),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Nothing,DiffEqBase.StandardODEProblem},Tsit5,OrdinaryDiffEq.InterpolationData{ODEFunction{false,getfield(Main, Symbol("##7#8")),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}},1},Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},1},Array{Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-3//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1), Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, -1//1)),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-3//1))}}},1},1},OrdinaryDiffEq.Tsit5ConstantCache{Float64,Float64}}},ODEFunction{false,getfield(Main, Symbol("##7#8")),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},OrdinaryDiffEq.Tsit5ConstantCache{Float64,Float64},OrdinaryDiffEq.DEOptions{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}},Float64,Float64,Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},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{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},DataStructures.LessThan},DataStructures.BinaryHeap{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},DataStructures.LessThan},Nothing,Nothing,Int64,Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},1},Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},1},Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},1}},Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-3//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1), Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, -1//1)),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-3//1))}}}}) at C:\Users\carsten\.julia\packages\OrdinaryDiffEq\d47lJ\src\integrators\integrator_interface.jl:250
 [4] #__init#203(::Int64, ::Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},1}, ::Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},1}, ::Array{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},1}, ::Nothing, ::Bool, ::Nothing, ::Bool, ::Bool, ::Nothing, ::Bool, ::Bool, ::Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}}, ::Bool, ::Rational{Int64}, ::Nothing, ::Nothing, ::Int64, ::Rational{Int64}, ::Int64, ::Int64, ::Rational{Int64}, ::Bool, ::Int64, ::Nothing, ::Nothing, ::Int64, ::Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}}, ::Float64, ::typeof(DiffEqBase.ODE_DEFAULT_NORM), ::typeof(LinearAlgebra.opnorm), ::typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), ::typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Int64, ::String, ::typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE), ::Nothing, ::Bool, ::Bool, ::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::typeof(DiffEqBase.__init), ::ODEProblem{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}},Tuple{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}}},false,Nothing,ODEFunction{false,getfield(Main, Symbol("##7#8")),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Nothing,DiffEqBase.StandardODEProblem}, ::Tsit5, ::Array{Any,1}, ::Array{Any,1}, ::Array{Any,1}, ::Type{Val{true}}) at C:\Users\carsten\.julia\packages\OrdinaryDiffEq\d47lJ\src\solve.jl:267
 [5] __init(::ODEProblem{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}},Tuple{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}}},false,Nothing,ODEFunction{false,getfield(Main, Symbol("##7#8")),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Nothing,DiffEqBase.StandardODEProblem}, ::Tsit5, ::Array{Any,1}, ::Array{Any,1}, ::Array{Any,1}, ::Type{Val{true}}) at C:\Users\carsten\.julia\packages\OrdinaryDiffEq\d47lJ\src\solve.jl:61
 [6] #__solve#202(::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::Function, ::ODEProblem{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}},Tuple{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}}},false,Nothing,ODEFunction{false,getfield(Main, Symbol("##7#8")),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Nothing,DiffEqBase.StandardODEProblem}, ::Tsit5, ::Array{Any,1}, ::Array{Any,1}, ::Array{Any,1}, ::Type{Val{true}}) at C:\Users\carsten\.julia\packages\OrdinaryDiffEq\d47lJ\src\solve.jl:6
 [7] __solve at C:\Users\carsten\.julia\packages\OrdinaryDiffEq\d47lJ\src\solve.jl:6 [inlined] (repeats 5 times)
 [8] #solve#429(::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::Function, ::ODEProblem{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}},Tuple{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}}},false,Nothing,ODEFunction{false,getfield(Main, Symbol("##7#8")),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Nothing,DiffEqBase.StandardODEProblem}, ::Tsit5) at C:\Users\carsten\.julia\packages\DiffEqBase\r9HLg\src\solve.jl:29
 [9] solve(::ODEProblem{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))},Unitful.FreeUnits{(Unitful.Unit{:Newton,Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Length}(1//1), Unitful.Dimension{:Mass}(1//1), Unitful.Dimension{:Time}(-2//1))}}},Tuple{Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}},Quantity{Float64,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)},Unitful.FreeUnits{(Unitful.Unit{:Second,Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}(0, 1//1),),Unitful.Dimensions{(Unitful.Dimension{:Time}(1//1),)}}}},false,Nothing,ODEFunction{false,getfield(Main, Symbol("##7#8")),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Nothing,DiffEqBase.StandardODEProblem}, ::Tsit5) at C:\Users\carsten\.julia\packages\DiffEqBase\r9HLg\src\solve.jl:21
 [10] top-level scope at In[3]:3

System of ODEs with units fails for me

Solving a system ODEs using unitful fails:
Running:

`using DifferentialEquations, Unitful

function g(dydt, y, p, t)
dydt[1] = -p[1] / p[2] * sin(y[2])
dydt[2] = y[1]
end

tspan = (0.0u"s",4.0u"s")
Y0=[0. * u"rad/s", .5u"rad"]
p = [9.8u"m/s^2",1u"m"]
prob = ODEProblem(g,Y0, tspan,p)

#Pass to solvers
sol = solve(prob,Tsit5())
`

produces:

MethodError: no method matching Quantity{Float64,D,U} where U where D(::Int64)
Closest candidates are:
Quantity{Float64,D,U} where U where D(::T<:Number) where T<:Number at boot.jl:725
Quantity{Float64,D,U} where U where D(!Matched::Base.TwicePrecision) where T<:Number at twiceprecision.jl:243
Quantity{Float64,D,U} where U where D(!Matched::AbstractChar) where T<:Union{AbstractChar, Number} at char.jl:50

ArbNumerics does not use Nemo, or ArbFloats

ArbNumerics does not use Nemo (or rely on the libraries Nemo generates for Nemo [it generates those libraries for itself]), nor does it use ArbFloats.jl. Just pkg> add ArbNumerics and you are good to go.

"IJulia Notebook Tutorials" instructions outdated

Early in the docs are these instructions:

#Pkg.add("IJulia") # Need to do this the first time to install IJulia!
Pkg.clone("https://github.com/JuliaDiffEq/DiffEqTutorials.jl")
using IJulia
notebook(dir = Pkg.dir("DiffEqTutorials"))

But these are outdated as of v0.7 - here's the error:

julia> #Pkg.add("IJulia") # Need to do this the first time to install IJulia!
       Pkg.clone("https://github.com/JuliaDiffEq/DiffEqTutorials.jl")
WARNING: Base.Pkg is deprecated, run `using Pkg` instead
 in module Main
┌ Warning: Pkg.clone is only kept for legacy CI script reasons, please use `add`
└ @ Pkg.API /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v0.7/Pkg/src/API.jl:445
  Updating git-repo `https://github.com/JuliaDiffEq/DiffEqTutorials.jl`
[ Info: Assigning UUID 225cb15b-72e6-54e6-9a40-306d353791de to DiffEqTutorials
ERROR: Path `/home/chad/.julia/dev/DiffEqTutorials` exists but it does not contain `src/DiffEqTutorials.jl
Stacktrace:
 [1] pkgerror(::String) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v0.7/Pkg/src/Types.jl:120
 [2] (::getfield(Pkg.Types, Symbol("##25#28")){Pkg.Types.Context,Array{Pkg.Types.PackageSpec,1},String})(::LibGit2.CachedCredentials) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v0.7/Pkg/src/Types.jl:571
 [3] shred!(::getfield(Pkg.Types, Symbol("##25#28")){Pkg.Types.Context,Array{Pkg.Types.PackageSpec,1},String}, ::LibGit2.CachedCredentials) at ./secretbuffer.jl:184
 [4] handle_repos_develop! at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v0.7/Pkg/src/Types.jl:498 [inlined]
 [5] #add_or_develop#13(::Symbol, ::Bool, ::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::Function, ::Pkg.Types.Context, ::Array{Pkg.Types.PackageSpec,1}) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v0.7/Pkg/src/API.jl:52
 [6] #add_or_develop at ./none:0 [inlined]
 [7] #develop#19 at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v0.7/Pkg/src/API.jl:70 [inlined]
 [8] develop at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v0.7/Pkg/src/API.jl:70 [inlined]
 [9] macro expansion at ./logging.jl:310 [inlined]
 [10] clone(::String, ::String) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v0.7/Pkg/src/API.jl:445 (repeats 2 times)
 [11] top-level scope at none:0

julia> using IJulia

julia> notebook(dir = Pkg.dir("DiffEqTutorials"))
WARNING: Base.Pkg is deprecated, run `using Pkg` instead
 in module Main
┌ Warning: `Pkg.dir(pkgname, paths...)` is deprecated; instead, do `import DiffEqTutorials; joinpath(dirname(pathof(DiffEqTutorials)), "..", paths...)`.
└ @ Pkg.API /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v0.7/Pkg/src/API.jl:454
ERROR: TypeError: in Type, in typeassert, expected AbstractString, got Nothing
Stacktrace:
 [1] (::getfield(Core, Symbol("#kw#Type")))(::NamedTuple{(:detach, :dir),Tuple{Bool,Nothing}}, ::Type{Cmd}, ::Cmd) at ./none:0
 [2] #notebook#1(::Nothing, ::Bool, ::Function) at /home/chad/.julia/packages/IJulia/4VL8h/src/IJulia.jl:120
 [3] (::getfield(IJulia, Symbol("#kw##notebook")))(::NamedTuple{(:dir,),Tuple{Nothing}}, ::typeof(notebook)) at ./none:0
 [4] top-level scope at none:0

problem with animation

Sorry for bothering you with this but I am trying to put together a notebook that animates the solution to the diffusion equation. The code below works well for plotting slices but the animation seems to go on and on and never make an animation.

Any suggestions as to what I'm doing wrong?

Needless to say, I am happy to share the notebook in case anyone might find it helpful.

# Import packages
using DiffEqOperators, DifferentialEquations, Plots

x = collect(-pi : 2pi/511 : pi);
u0 = -(x - 0.5).^2 + 1/12;
A = DerivativeOperator{Float64}(2,2,2pi/511,512,:Dirichlet,:Dirichlet;BC=(u0[1],u0[end]));

prob1 = ODEProblem(A, u0, (0.,10.));
sol1 = solve(prob1, dense=false, tstops=0:0.01:0.1);
    
# try to plot the solution at different time points using
plot(x, [sol1(i) for i in 0:1:10])

animate(sol1,"tmp.gif")

ExtraFEMFeatures/Heat Equation

I am very new to Julia and going through some of the neat tutorials people have put together.

I installed Julia 0.6.0 on Ubunbu by downloading the generic version, as requested.

When I run the Heat Equation example the first line seems to go okay but the second has a MethodError, suggesting a method might be too new.

To be able to use this example should I use the most recent (bleeding edge) version? I am happy to do that but wanted to check to see if this is what is necessary.

MethodError: no method matching setcharheight(::Float64)
The applicable method may be too new: running in world age 24141, while current world is 24142.
Closest candidates are:
setcharheight(::Real) at /home/fpoulin/.julia/v0.6/GR/src/GR.jl:1010 (method too new to be called from this world context.)

Stacktrace:
 [1] #gr_set_font#316(::Symbol, ::Symbol, ::ColorTypes.RGB{FixedPointNumbers.Normed{UInt8,8}}, ::Int64, ::Function, ::Plots.Font) at /home/fpoulin/.julia/v0.6/Plots/src/backends/gr.jl:374
 [2] (::Plots.#kw##gr_set_font)(::Array{Any,1}, ::Plots.#gr_set_font, ::Plots.Font) at ./<missing>:0
 [3] gr_set_xticks_font(::Plots.Subplot{Plots.GRBackend}) at /home/fpoulin/.julia/v0.6/Plots/src/backends/gr.jl:561
 [4] _update_min_padding!(::Plots.Subplot{Plots.GRBackend}) at /home/fpoulin/.julia/v0.6/Plots/src/backends/gr.jl:612
 [5] _collect(::Array{RecipesBase.AbstractLayout,2}, ::Base.Generator{Array{RecipesBase.AbstractLayout,2},Plots.#_update_min_padding!}, ::Base.EltypeUnknown, ::Base.HasShape) at ./array.jl:454
 [6] _update_min_padding!(::Plots.GridLayout) at /home/fpoulin/.julia/v0.6/Plots/src/layouts.jl:310
 [7] prepare_output(::Plots.Plot{Plots.GRBackend}) at /home/fpoulin/.julia/v0.6/Plots/src/plot.jl:258
 [8] show(::IOStream, ::MIME{Symbol("image/png")}, ::Plots.Plot{Plots.GRBackend}) at /home/fpoulin/.julia/v0.6/Plots/src/output.jl:207
 [9] png(::Plots.Plot{Plots.GRBackend}, ::String) at /home/fpoulin/.julia/v0.6/Plots/src/output.jl:8
 [10] frame(::Plots.Animation, ::Plots.Plot{Plots.GRBackend}) at /home/fpoulin/.julia/v0.6/Plots/src/animation.jl:20
 [11] #animate#252(::Array{Any,1}, ::Function, ::Plots.FrameIterator, ::String) at /home/fpoulin/.julia/v0.6/Plots/src/animation.jl:43
 [12] (::RecipesBase.#kw##animate)(::Array{Any,1}, ::RecipesBase.#animate, ::Plots.FrameIterator, ::String) at ./<missing>:0 (repeats 2 times)
 [13] include_string(::String, ::String) at ./loading.jl:515

Outdated tutorial

This tutorial seems outdated.
This line:

prob_femheat_diffusionconstants = HeatProblem(u₀,f,D=[.01 .001])

throws

ERROR: MethodError: no method matching DiffEqPDEBase.HeatProblem{islinear,isstochastic,MeshType,F,F2,F3,F4,F5,F6,F7,DiffType}(::##3#4, ::##1#2; D=[0.01 0.001])
Closest candidates are:
  DiffEqPDEBase.HeatProblem{islinear,isstochastic,MeshType,F,F2,F3,F4,F5,F6,F7,DiffType}(::Any, ::Any, ::Any; noisetype, gD, gN, σ, numvars, D) at /home/blegat/.julia/v0.5/DiffEqPDEBase/src/problems.jl:41
  DiffEqPDEBase.HeatProblem{islinear,isstochastic,MeshType,F,F2,F3,F4,F5,F6,F7,DiffType}(::Any, ::Any, ::Any, ::Any; noisetype, gN, σ, numvars, D) at /home/blegat/.julia/v0.5/DiffEqPDEBase/src/problems.jl:16
  DiffEqPDEBase.HeatProblem{islinear,isstochastic,MeshType,F,F2,F3,F4,F5,F6,F7,DiffType}{T}(::Any) at sysimg.jl:53 got unsupported keyword argument "D"
 in eval_user_input(::Any, ::Base.REPL.REPLBackend) at ./REPL.jl:64
 in macro expansion at ./REPL.jl:95 [inlined]
 in (::Base.REPL.##3#4{Base.REPL.REPLBackend})() at ./event.jl:68

Missing dependencies

When I did the rebuild of most of the tutorials some days ago, I've noticed that I had to install several packages by hand to succeed. I wrote them down:

  • DiffeqBiological
  • PyPlot
  • Latexify
  • ModelingToolkit
  • NLsolve
  • Distributions
  • StatsPlots
  • Cairo

Should these packages be added to Project.toml?
If so, does this need be done by hand? How do I get the UUID of such a package?

Installation issues

At least for me, the package could not just be added as described in the README. I was initially getting an error about:

ERROR: Unsatisfiable requirements detected for package UnitfulPlots [2a06ce6d]:
 UnitfulPlots [2a06ce6d] log:
 ├─UnitfulPlots [2a06ce6d] has no known versions!
 └─restricted to versions * by DiffEqTutorials [6d1b261a] — no versions left
   └─DiffEqTutorials [6d1b261a] log:
     ├─possible versions are: 0.1.0 or uninstalled
     └─DiffEqTutorials [6d1b261a] is fixed to version 0.1.0

It seems UnitfulPlots is not in the registry, so one has to explicitly add it from the Github repository. This might be worth mentioning as I imagine tutorials users may not be able to figure out these types of issues on their own...

footer in scripts

At the end of scripts the following code gets added, but seems not to be run-able:

using DiffEqTutorials
DiffEqTutorials.tutorial_footer(WEAVE_ARGS[:folder],WEAVE_ARGS[:file])

Should this be removed from .jl files?

Unsatisfiable requirements detected

Hi all,

using Pkg
pkg"add https://github.com/JuliaDiffEq/DiffEqTutorials.jl"

Updating registry at /opt/julia/registries/General
Updating git-repo https://github.com/JuliaRegistries/General.git
[1mFetching: [========================================>] 100.0 %.0 % Updating git-repo https://github.com/JuliaDiffEq/DiffEqTutorials.jl
Updating git-repo https://github.com/JuliaDiffEq/DiffEqTutorials.jl
Resolving package versions...
Unsatisfiable requirements detected for package Gadfly [c91e804a]:
Gadfly [c91e804a] log:
├─possible versions are: [0.8.0, 1.0.0-1.0.1, 1.1.0] or uninstalled
├─restricted to versions 1.1.0-1 by DiffEqTutorials [6d1b261a], leaving only versions 1.1.0
│ └─DiffEqTutorials [6d1b261a] log:
│ ├─possible versions are: 0.2.0 or uninstalled
│ └─DiffEqTutorials [6d1b261a] is fixed to version 0.2.0
└─restricted by compatibility requirements with Distributions [31c24e10] to versions: [0.8.0, 1.0.0-1.0.1] or uninstalled — no versions left
└─Distributions [31c24e10] log:
├─possible versions are: [0.16.0-0.16.4, 0.17.0, 0.18.0, 0.19.1-0.19.2, 0.20.0, 0.21.0-0.21.3, 0.21.5-0.21.11] or uninstalled
└─restricted to versions 0.21.0-0.21 by DiffEqTutorials [6d1b261a], leaving only versions [0.21.0-0.21.3, 0.21.5-0.21.11]
└─DiffEqTutorials [6d1b261a] log: see above

Stacktrace:
[1] #propagate_constraints!#61(::Bool, ::typeof(Pkg.GraphType.propagate_constraints!), ::Pkg.GraphType.Graph, ::Set{Int64}) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.2/Pkg/src/GraphType.jl:1007
[2] propagate_constraints! at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.2/Pkg/src/GraphType.jl:948 [inlined]
[3] #simplify_graph!#121(::Bool, ::typeof(Pkg.GraphType.simplify_graph!), ::Pkg.GraphType.Graph, ::Set{Int64}) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.2/Pkg/src/GraphType.jl:1462
[4] simplify_graph! at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.2/Pkg/src/GraphType.jl:1462 [inlined]
[5] resolve_versions!(::Pkg.Types.Context, ::Array{Pkg.Types.PackageSpec,1}) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.2/Pkg/src/Operations.jl:317
[6] #add#100(::Bool, ::typeof(Pkg.Operations.add), ::Pkg.Types.Context, ::Array{Pkg.Types.PackageSpec,1}, ::Array{Base.UUID,1}) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.2/Pkg/src/Operations.jl:962
[7] #add at ./none:0 [inlined]
[8] #add#25(::Bool, ::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::typeof(Pkg.API.add), ::Pkg.Types.Context, ::Array{Pkg.Types.PackageSpec,1}) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.2/Pkg/src/API.jl:99
[9] add at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.2/Pkg/src/API.jl:69 [inlined]
[10] do_add!(::Dict{Symbol,Any}, ::Array{Pkg.Types.PackageSpec,1}, ::Dict{Symbol,Any}) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.2/Pkg/src/REPLMode.jl:496
[11] #invokelatest#1(::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::typeof(Base.invokelatest), ::Any, ::Any, ::Vararg{Any,N} where N) at ./essentials.jl:790
[12] invokelatest(::Any, ::Any, ::Vararg{Any,N} where N) at ./essentials.jl:789
[13] do_cmd!(::Pkg.REPLMode.Command, ::Pkg.REPLMode.MiniREPL) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.2/Pkg/src/REPLMode.jl:403
[14] #do_cmd#23(::Bool, ::typeof(Pkg.REPLMode.do_cmd), ::Pkg.REPLMode.MiniREPL, ::String) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.2/Pkg/src/REPLMode.jl:382
[15] (::getfield(Pkg.REPLMode, Symbol("#kw##do_cmd")))(::NamedTuple{(:do_rethrow,),Tuple{Bool}}, ::typeof(Pkg.REPLMode.do_cmd), ::Pkg.REPLMode.MiniREPL, ::String) at ./none:0
[16] top-level scope at In[1]:2

I'm on

versioninfo()

Julia Version 1.2.0
Commit c6da87ff4b (2019-08-20 00:03 UTC)
Platform Info:
OS: Linux (x86_64-pc-linux-gnu)
CPU: Intel(R) Xeon(R) Gold 6140 CPU @ 2.30GHz
WORD_SIZE: 64
LIBM: libopenlibm
LLVM: libLLVM-6.0.1 (ORCJIT, skylake)
Environment:
JULIA_DEPOT_PATH = /opt/julia
JULIA_VERSION = 1.2.0
JULIA_PKGDIR = /opt/julia

Has anyone else experienced a similar issue?

Remove the PDFs?

The .md's seem to serve a very similar purpose and are much easier to manage updates to. I think it might make sense to stop generating them by default. Though they are sometimes nice for handouts in a classroom setting or workshops

How can I run the interactive notebook

I've install Julia and jupyter notebook. After that what should I do?
I don't understand

install the package and open the tutorials like:

Is it a pakcage manager or something else? How can I install that package?
Where should I type in the command

using Pkg
pkg"add https://github.com/JuliaDiffEq/DiffEqTutorials.jl"
using DiffEqTutorials
DiffEqTutorials.open_notebooks()

Update Dynamical ODE Tutorials

Now that there's a "set interface" which is much better for handling these, we should convert the tutorials in here over to using that. So SecondOrderODEProblem and DynamicalODEProblem instead of defining by tuples (though it does lower to the same thing, except using the DynamicalODEProblem so that first-order ODE methods work via an automatic transformation).

@YingboMa

Weave.jl issues

Current Weave.jl issues:

  • Unitful tutorial breaks Weave.jl JunoLab/Weave.jl#175
  • Measurements.jl tutorial gives an issue with Weave.jl's latex function
  • Weave.jl's notebook output is currently broken. For this package we simply disabled those outputs for now.
  • HTML does not render TeX: JunoLab/Weave.jl#178

Outdated examples

Some examples, like the first one for SDEs, seem to be outdated and currently do not work. The equivalent SDE example on the manual is here and does work.

I suggest to get rid of the notebook tutorials, it will be easier to manage only one set of examples.

Small bug in Outer-Solar System notebook

Re-running Outer-Solar System.ipynb after the recent update, at

prob = NBodyProblem(V, M, pos, vel, tspan)
@time sol = solve(prob, Yoshida6(), dt=100);

The following error occurs:

AssertionError: dim * length(mass) == N

Stacktrace:
[1] #NBodyProblem#1(::Array{Any,1}, ::Function, ::Function, ::Diagonal{Float64}, ::Array{Float64,1}, ::Array{Float64,1}, ::Tuple{Float64,Int64}) at C:\Users\Denis.julia\v0.6\DiffEqPhysics\src\nbody.jl:9
[2] NBodyProblem(::Function, ::Diagonal{Float64}, ::Array{Float64,1}, ::Array{Float64,1}, ::Tuple{Float64,Int64}) at C:\Users\Denis.julia\v0.6\DiffEqPhysics\src\nbody.jl:5
[3] include_string(::String, ::String) at .\loading.jl:522

Unsatisfiable requirements detected for package Gadfly

(v1.3) pkg> add .
  Updating git-repo `/home/scheme/DiffEqTutorials.jl`
  Updating git-repo `/home/scheme/DiffEqTutorials.jl`
 Resolving package versions...
ERROR: Unsatisfiable requirements detected for package Gadfly [c91e804a]:
 Gadfly [c91e804a] log:
 ├─possible versions are: [0.8.0, 1.0.0-1.0.1, 1.1.0] or uninstalled
 ├─restricted to versions 1.1.0-1 by DiffEqTutorials [6d1b261a], leaving only versions 1.1.0
 │ └─DiffEqTutorials [6d1b261a] log:
 │   ├─possible versions are: 0.2.1 or uninstalled
 │   └─DiffEqTutorials [6d1b261a] is fixed to version 0.2.1
 └─restricted by compatibility requirements with Distributions [31c24e10] to versions: [0.8.0, 1.0.0-1.0.1] or uninstalled — no versions left
   └─Distributions [31c24e10] log:
     ├─possible versions are: [0.16.0-0.16.4, 0.17.0, 0.18.0, 0.19.1-0.19.2, 0.20.0, 0.21.0-0.21.3, 0.21.5-0.21.12] or uninstalled
     ├─restricted to versions 0.21 by DiffEqSensitivity [41bf760c], leaving only versions [0.21.0-0.21.3, 0.21.5-0.21.12]
     │ └─DiffEqSensitivity [41bf760c] log:
     │   ├─possible versions are: 6.1.0 or uninstalled
     │   └─DiffEqSensitivity [41bf760c] is fixed to version 6.1.0
     └─restricted by compatibility requirements with SpecialFunctions [276daf66] to versions: [0.16.0-0.16.4, 0.17.0, 0.18.0, 0.19.1-0.19.2, 0.21.11-0.21.12] or uninstalled, leaving only versions: 0.21.11-0.21.12
       └─SpecialFunctions [276daf66] log:
         ├─possible versions are: [0.7.0-0.7.2, 0.8.0, 0.9.0] or uninstalled
         └─restricted to versions 0.9.0 by an explicit requirement, leaving only versions 0.9.0

I tried to remove Gadfly from Project.toml, but it didn't help.

Tutorial - Heat Equation Finite Element Method

Hi,

the code in the heat equation tutorial gives the following error for me:

using DifferentialEquations

f(t,x,u)  = ones(size(x,1)) - .5u
u0_func(x) = zeros(size(x,1))

tspan = (0.0,1.0)
dx = 1//2^(3)
dt = 1//2^(7)

mesh = parabolic_squaremesh([0 1 0 1],dx,dt,tspan,:neumann)
u0 = u0_func(mesh.node)
prob = HeatProblem(u0,f,mesh)

sol = solve(prob,FEMDiffEqHeatImplicitEuler())
Error displaying DiffEqPDEBase.FEMSolution{Float64,2,Array{Array{Float64,1},1},Void,Dict{Symbol,Float64},Array{Float64,1},DiffEqPDEBase.HeatProblem{false,false,DiffEqPDEBase.FEMMesh{Array{Rational{Int64},2},Array{Float64,1},Rational{Int64},Tuple{Float64,Float64}},#f,Void,DiffEqPDEBase.##21#30,DiffEqPDEBase.##22#31,Array{Float64,1},DiffEqPDEBase.##14#23,Void,Float64}}: type FEMSolution has no field retcode
show at solution_interface.jl:34 [inlined]
(::LastMain.Juno.##1#2{DiffEqPDEBase.FEMSolution{Float64,2,Array{Array{Float64,1},1},Void,Dict{Symbol,Float64},Array{Float64,1},DiffEqPDEBase.HeatProblem{false,false,DiffEqPDEBase.FEMMesh{Array{Rational{Int64},2},Array{Float64,1},Rational{Int64},Tuple{Float64,Float64}},#f,Void,DiffEqPDEBase.##21#30,DiffEqPDEBase.##22#31,Array{Float64,1},DiffEqPDEBase.##14#23,Void,Float64}}})(::Base.AbstractIOBuffer{Array{UInt8,1}}) at types.jl:11
#sprint#228(::Void, ::Function, ::Int64, ::Function) at io.jl:66
Type at types.jl:51 [inlined]
Type at types.jl:52 [inlined]
render(::LastMain.Juno.Editor, ::DiffEqPDEBase.FEMSolution{Float64,2,Array{Array{Float64,1},1},Void,Dict{Symbol,Float64},Array{Float64,1},DiffEqPDEBase.HeatProblem{false,false,DiffEqPDEBase.FEMMesh{Array{Rational{Int64},2},Array{Float64,1},Rational{Int64},Tuple{Float64,Float64}},#f,Void,DiffEqPDEBase.##21#30,DiffEqPDEBase.##22#31,Array{Float64,1},DiffEqPDEBase.##14#23,Void,Float64}}) at types.jl:13
render′(::LastMain.Juno.Editor, ::DiffEqPDEBase.FEMSolution{Float64,2,Array{Array{Float64,1},1},Void,Dict{Symbol,Float64},Array{Float64,1},DiffEqPDEBase.HeatProblem{false,false,DiffEqPDEBase.FEMMesh{Array{Rational{Int64},2},Array{Float64,1},Rational{Int64},Tuple{Float64,Float64}},#f,Void,DiffEqPDEBase.##21#30,DiffEqPDEBase.##22#31,Array{Float64,1},DiffEqPDEBase.##14#23,Void,Float64}}) at errors.jl:106
(::LastMain.Atom.##50#54{String})() at eval.jl:57
macro expansion at eval.jl:53 [inlined]
(::LastMain.Atom.##48#52{Dict{String,Any}})() at task.jl:80

Running Julia v0.6.1 with DifferentialEquations v3.0.2

Update most if not all notebooks

@ChrisRackauckas Can you or someone please update most if not all notebooks in DiffEqTutorials to run smoothly on current Julia v1.0.1 and DifferentialEquations v5.3.1. For a fruitful dissemination of Julia DiffEq, it is important that this collection of notebooks runs flawlessly.

small typo in Chemical Langevin Equation

Hi Samuel, thanks for the nice tutorial! Just wanted to point out a small mistake in the text of DiffEqBiological Tutorial I: Introduction. In the CLE example you define a reaction network

bdp = @reaction_network begin
  c₁, X --> 2X
  c₂, X --> 0
  c₃, 0 --> X
end c₁ c₂ c₃
p = (1.0,2.0,50.)
u₀ = [5.]
tspan = (0.,4.);

and then mention that the corresponding SDE is
dX_t = \left(c_1 X - c_2 X + c_3 \right) dt + \left( \sqrt{c_1 X} - \sqrt{c_2 X} + \sqrt{c_3} \right)dW_t
I think that should be either
dX_t = \left(c_1 X - c_2 X + c_3 \right) dt + \sqrt{c_1 X} dW^1_t - \sqrt{c_2 X} dW^2_t + \sqrt{c_3}dW^3_t
where W_t is a 3-dimensional Wiener process, or perhaps
dX_t = \left(c_1 X - c_2 X + c_3 \right) dt + \sqrt{c_1 X + c_2 X + c_3}dW_t
with a 1-dimensional Wiener process. But I reckon the implementation uses the 3-dim process.

some bugs

Hi all,

how can I remove the following bugs:

UndefVarError: sol not defined

UndefVarError: Yoshida6 not defined

UndefVarError: prob not defined

Thanks a lot in advance!

Best regards

Weave related issues

  1. using Plots.jl with PyPlot and fmt=:svg the generated html file uses png files. The notebook seems to use svg.
  2. Latex generation is somehow not creating a figure folder that is then referenced in the .tex file. Specifically, the figure
 \includegraphics[width=\linewidth {/Users/isaacsas/.julia/dev/DiffEqTutorials/pdf/models/tmpICR6PZ/diffeqbio_I_introduction_10_1.pdf}

is missing when compiling latex. Note, my latex compile fails initially due to Latexify using the mhchem package and including a necessary command in the generated environment that is mathjax specific. I was initially able to edit the .tex file and get it to compile as the missing figure issue wasn't happening. After deleting all the Latex output, including tmp file folders, to try to start over I am getting this issue (even in a new REPL). I also upgraded to the latest master.

Still issues with DiffEq + Unitful

Related to #29.

The unitful example in the notebooks now works. However this maybe slightly advanced example does not.

using DifferentialEquations
import Unitful: s, m, kg, N

# coordinate: u = [position, momentum]
# parameters: p = [mass, force constanst]
function f_harmonic!(du,u,p,t)
  du[1] = u[2]/p[1]
  du[2] = -p[2]/p[1]*u[1]
end

mass = 1.0kg
k = 1.0N/m
p = [mass, k]

u0 = [1.0m, 0.0kg*m/s] # initial values (position, momentum)

tspan = (0.0s, 10.0s)

prob = ODEProblem(f_harmonic!, u0, tspan, p)

sol = solve(prob)

Running this I get

MethodError: no method matching Quantity{Float64,D,U} where U where D(::Int64)
Closest candidates are:
  Quantity{Float64,D,U} where U where D(::T<:Number) where T<:Number at boot.jl:725
  Quantity{Float64,D,U} where U where D(!Matched::Base.TwicePrecision) where T<:Number at twiceprecision.jl:243
  Quantity{Float64,D,U} where U where D(!Matched::AbstractChar) where T<:Union{AbstractChar, Number} at char.jl:50

Error When Following Heat Eqn. Tutorial

Hello,

I am using DifferentialEquations.jl version 6.8.0 and attempting to follow the tutorial at https://docs.juliadiffeq.org/v1.10.1/tutorials/femheat_example.html
and I have an error when running the line mesh = parabolic_squaremesh([0 1 0 1],dx,dt,tspan,:neumann)

I get the message "UndefVarError: parabolic_squaremesh not defined." When I try to update DiffEqPDEBase I get the following message:

ERROR: Unsatisfiable requirements detected for package DiffEqBase [2b5f629d]: DiffEqBase [2b5f629d] log: ├─possible versions are: [3.13.2-3.13.3, 4.0.0-4.0.1, 4.1.0, 4.2.0, 4.3.0-4.3.1, 4.4.0, 4.5.0, 4.6.0, 4.7.0, 4.8.0, 4.9.0, 4.10.0-4.10.1, 4.11.0-4.11.1, 4.12.0, 4.13.0, 4.14.0-4.14.1, 4.15.0, 4.16.0, 4.17.0, 4.18.0, 4.19.0, 4.20.0-4.20.3, 4.21.0, 4.21.2-4.21.3, 4.22.0-4.22.2, 4.23.0, 4.23.2-4.23.4, 4.24.0-4.24.3, 4.25.0-4.25.1, 4.26.0-4.26.3, 4.27.0-4.27.1, 4.28.0-4.28.1, 4.29.0-4.29.2, 4.30.0-4.30.2, 4.31.0-4.31.2, 4.32.0, 5.0.0-5.0.1, 5.1.0, 5.2.0-5.2.3, 5.3.0-5.3.2, 5.4.0-5.4.1, 5.5.0-5.5.2, 5.6.0-5.6.4, 5.7.0, 5.8.0-5.8.1, 5.9.0, 5.10.0-5.10.3, 5.11.0-5.11.1, 5.12.0, 5.13.0, 5.14.0-5.14.2, 5.15.0, 5.16.0-5.16.5, 5.17.0-5.17.1, 5.18.0, 5.19.0, 5.20.0-5.20.1, 6.0.0, 6.1.0, 6.2.0-6.2.4, 6.3.0-6.3.6, 6.4.0-6.4.2] or uninstalled ├─restricted by compatibility requirements with DifferentialEquations [0c46a032] to versions: [6.2.2-6.2.4, 6.3.0-6.3.6, 6.4.0-6.4.2] │ └─DifferentialEquations [0c46a032] log: │ ├─possible versions are: [5.0.0, 5.1.0, 5.2.0-5.2.1, 5.3.0-5.3.1, 6.0.0, 6.1.0, 6.2.0, 6.3.0, 6.4.0, 6.6.0, 6.7.0, 6.8.0] or uninstalled │ └─restricted to versions 6.8.0 by an explicit requirement, leaving only versions 6.8.0 └─restricted by compatibility requirements with DiffEqPDEBase [34035eb4] to versions: [3.13.2-3.13.3, 4.0.0-4.0.1, 4.1.0, 4.2.0, 4.3.0-4.3.1, 4.4.0, 4.5.0, 4.6.0, 4.7.0, 4.8.0, 4.9.0, 4.10.0-4.10.1, 4.11.0-4.11.1, 4.12.0, 4.13.0, 4.14.0-4.14.1, 4.15.0, 4.16.0, 4.17.0, 4.18.0, 4.19.0, 4.20.0-4.20.3, 4.21.0, 4.21.2-4.21.3, 4.22.0-4.22.2, 4.23.0, 4.23.2-4.23.4, 4.24.0-4.24.3, 4.25.0-4.25.1, 4.26.0-4.26.3, 4.27.0-4.27.1, 4.28.0-4.28.1, 4.29.0-4.29.2, 4.30.0-4.30.2, 4.31.0-4.31.2, 4.32.0, 5.0.0-5.0.1, 5.1.0, 5.2.0-5.2.3, 5.3.0-5.3.2, 5.4.0-5.4.1, 5.5.0-5.5.2, 5.6.0-5.6.4, 5.7.0, 5.8.0-5.8.1, 5.9.0, 5.10.0-5.10.3, 5.11.0-5.11.1, 5.12.0, 5.13.0, 5.14.0-5.14.2, 5.15.0, 5.16.0-5.16.5, 5.17.0-5.17.1, 5.18.0, 5.19.0, 5.20.0-5.20.1] — no versions left └─DiffEqPDEBase [34035eb4] log: ├─possible versions are: 0.4.0 or uninstalled └─restricted to versions * by an explicit requirement, leaving only versions 0.4.0

Is there a better way to call the meshing function, or is there some way to update the required dependency DiffEqPDEBase?

html files not rendering in Github

The ones I looked at seem to just be rendering as raw text in Github. Is this what's supposed to happen? With the notebooks no longer having figures it would be nice if the html files were rendered so we could link to them from different places.

Example Radioactive Decay (Numbers with uncertainties) not working in Julia 1.0

Source: http://nbviewer.jupyter.org/github/JuliaDiffEq/DiffEqTutorials.jl/blob/master/PhysicalModels/NumberUncertainties.ipynb

If I execute

# Half-life of radiocarbon, in thousands of years
c = 5.730 ± 0.040

#Setup
u₀ = 1 ± 0
tspan = (0 ± 0, 1 ± 0)

#Define the problem
radioactivedecay(u,p,t) = -c * u

#Pass to solver
prob = ODEProblem(radioactivedecay, u₀, tspan)
sol = solve(prob, Tsit5())

in Julia 1.0 I get:

MethodError: Measurement{Float64}(::Rational{Int64}) is ambiguous. Candidates:
  (::Type{Measurement{T}})(x::S) where {T, S} in Measurements at C:\Users\carsten\.julia\packages\Measurements\57KtG\src\Measurements.jl:61
  (::Type{T})(x::Rational{S}) where {S, T<:AbstractFloat} in Base at rational.jl:90
Possible fix, define
  (::Type{Measurement{T}})(::Rational{S})

Stacktrace:
 [1] #__init#203(::Int64, ::Array{Measurement{Float64},1}, ::Array{Measurement{Float64},1}, ::Array{Measurement{Float64},1}, ::Nothing, ::Bool, ::Nothing, ::Bool, ::Bool, ::Nothing, ::Bool, ::Bool, ::Measurement{Float64}, ::Bool, ::Rational{Int64}, ::Nothing, ::Nothing, ::Int64, ::Rational{Int64}, ::Int64, ::Int64, ::Rational{Int64}, ::Bool, ::Int64, ::Nothing, ::Nothing, ::Int64, ::Measurement{Float64}, ::Float64, ::typeof(DiffEqBase.ODE_DEFAULT_NORM), ::typeof(LinearAlgebra.opnorm), ::typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), ::typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Int64, ::String, ::typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE), ::Nothing, ::Bool, ::Bool, ::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::typeof(DiffEqBase.__init), ::ODEProblem{Measurement{Float64},Tuple{Measurement{Float64},Measurement{Float64}},false,Nothing,ODEFunction{false,typeof(radioactivedecay),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Nothing,DiffEqBase.StandardODEProblem}, ::Tsit5, ::Array{Any,1}, ::Array{Any,1}, ::Array{Any,1}, ::Type{Val{true}}) at C:\Users\carsten\.julia\packages\OrdinaryDiffEq\nZPqS\src\solve.jl:80
 [2] __init(::ODEProblem{Measurement{Float64},Tuple{Measurement{Float64},Measurement{Float64}},false,Nothing,ODEFunction{false,typeof(radioactivedecay),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Nothing,DiffEqBase.StandardODEProblem}, ::Tsit5, ::Array{Any,1}, ::Array{Any,1}, ::Array{Any,1}, ::Type{Val{true}}) at C:\Users\carsten\.julia\packages\OrdinaryDiffEq\nZPqS\src\solve.jl:61
 [3] #__solve#202(::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::Function, ::ODEProblem{Measurement{Float64},Tuple{Measurement{Float64},Measurement{Float64}},false,Nothing,ODEFunction{false,typeof(radioactivedecay),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Nothing,DiffEqBase.StandardODEProblem}, ::Tsit5, ::Array{Any,1}, ::Array{Any,1}, ::Array{Any,1}, ::Type{Val{true}}) at C:\Users\carsten\.julia\packages\OrdinaryDiffEq\nZPqS\src\solve.jl:6
 [4] __solve(::ODEProblem{Measurement{Float64},Tuple{Measurement{Float64},Measurement{Float64}},false,Nothing,ODEFunction{false,typeof(radioactivedecay),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Nothing,DiffEqBase.StandardODEProblem}, ::Tsit5, ::Array{Any,1}, ::Array{Any,1}, ::Array{Any,1}, ::Type{Val{true}}) at C:\Users\carsten\.julia\packages\OrdinaryDiffEq\nZPqS\src\solve.jl:6 (repeats 5 times)
 [5] #solve#429(::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::Function, ::ODEProblem{Measurement{Float64},Tuple{Measurement{Float64},Measurement{Float64}},false,Nothing,ODEFunction{false,typeof(radioactivedecay),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Nothing,DiffEqBase.StandardODEProblem}, ::Tsit5) at C:\Users\carsten\.julia\packages\DiffEqBase\b3iNk\src\solve.jl:29
 [6] solve(::ODEProblem{Measurement{Float64},Tuple{Measurement{Float64},Measurement{Float64}},false,Nothing,ODEFunction{false,typeof(radioactivedecay),LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Nothing,DiffEqBase.StandardODEProblem}, ::Tsit5) at C:\Users\carsten\.julia\packages\DiffEqBase\b3iNk\src\solve.jl:21
 [7] top-level scope at In[6]:13

Package update and dirty DiffEqTutorials and DiffEqDocs

Although the git stash method has been advocated to solve this issue, it would be good to have the Pkg.update() working on all JuliaDiffEq packages.

Also what is the best way to download a Jupyter notebook from a DiffEqDocs Markdown/html page? For me, it is this step which dirties the packages.

Notebooks displayed in Jupyter are not ordered

The notebooks in the Jupyter overview are ordered alphabetically by default. It looks like this:
image
But the README suggests to work through the notebooks in a specific order:

  1. Introduction to DifferentialEquations.jl through ODEs
  2. Detecting Stiffness and Choosing an ODE Algorithm
  3. etc.

This could be solved by renaming the notebooks, e.g. 01-ode_introduction.ipynb instead of ode_introduction.ipynb

Add more dependencies to DiffEqTutorials?

On a fresh julia-1.1.0 install, I followed the "Getting started guide" for DifferentialEquations:

using Pkg
Pkg.add("DifferentialEquations")
using DifferentialEquations
using Pkg
pkg"add https://github.com/JuliaDiffEq/DiffEqTutorials.jl"
using DiffEqTutorials
DiffEqTutorials.open_notebooks()

So far I've needed to add IJulia, MatrixFactorizations, DiffEqParamEstim, Plots, Optim ... and perhaps a few more to come (haven't gone through the tutorial yet).

I am somewhat perplexed since I see these requirements listed here:
https://github.com/JuliaDiffEq/DiffEqTutorials.jl/blob/master/Project.toml

Is that pkg"add ..." special in the sense it doesn't pull the dependencies?

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.