Use explicit imports

Author: ChrisRackauckas

docs/src/basics/faq.md

@@ -478,9 +478,9 @@ function func(du, u, p, t)
     du[2] = -3 * u[2] + u[1] * u[2]
 end
 function f(p)
-    prob = ODEProblem(func, eltype(p).([1.0, 1.0]), (0.0, 10.0), p)
+    prob = DE.ODEProblem(func, eltype(p).([1.0, 1.0]), (0.0, 10.0), p)
     # Lower tolerances to show the methods converge to the same value
-    solve(prob, Tsit5(), save_everystep = false, abstol = 1e-12, reltol = 1e-12)[end]
+    DE.solve(prob, DE.Tsit5(), save_everystep = false, abstol = 1e-12, reltol = 1e-12)[end]
 end
 ```
 
@@ -508,14 +508,14 @@ This is because you're using a cache which is incompatible with autodifferentiat
 via ForwardDiff.jl. For example, if we use the ODE function:
 
 ```julia
-import LinearAlgebra, OrdinaryDiffEq
+import LinearAlgebra, OrdinaryDiffEq as ODE, DifferentialEquations
 function foo(du, u, (A, tmp), t)
     mul!(tmp, A, u)
     @. du = u + tmp
     nothing
 end
-prob = ODEProblem(foo, ones(5, 5), (0.0, 1.0), (ones(5, 5), zeros(5, 5)))
-solve(prob, Rosenbrock23())
+prob = DE.ODEProblem(foo, ones(5, 5), (0.0, 1.0), (ones(5, 5), zeros(5, 5)))
+DE.solve(prob, ODE.Rosenbrock23())
 ```
 
 Here we use a cached temporary array to avoid the allocations of matrix
@@ -527,8 +527,9 @@ option in the solver. Every solver which uses autodifferentiation has this optio
 Thus, we'd solve this with:
 
 ```julia
-prob = ODEProblem(f, ones(5, 5), (0.0, 1.0))
-sol = solve(prob, Rosenbrock23(autodiff = false))
+import DifferentialEquations, OrdinaryDiffEq as ODE
+prob = DE.ODEProblem(f, ones(5, 5), (0.0, 1.0))
+sol = DE.solve(prob, ODE.Rosenbrock23(autodiff = false))
 ```
 
 and it will use a numerical differentiation fallback (DiffEqDiffTools.jl) to
@@ -539,16 +540,16 @@ We could use `get_tmp` and `dualcache` functions from
 to solve this issue, e.g.,
 
 ```julia
-import LinearAlgebra, OrdinaryDiffEq, PreallocationTools
+import LinearAlgebra, OrdinaryDiffEq as ODE, PreallocationTools, DifferentialEquations
 function foo(du, u, (A, tmp), t)
-    tmp = get_tmp(tmp, first(u) * t)
+    tmp = PreallocationTools.get_tmp(tmp, first(u) * t)
     mul!(tmp, A, u)
     @. du = u + tmp
     nothing
 end
-prob = ODEProblem(foo, ones(5, 5), (0.0, 1.0),
+prob = DE.ODEProblem(foo, ones(5, 5), (0.0, 1.0),
     (ones(5, 5), PreallocationTools.dualcache(zeros(5, 5))))
-solve(prob, TRBDF2())
+DE.solve(prob, ODE.TRBDF2())
 ```
 
 ## Sparse Jacobians
@@ -570,7 +571,8 @@ ERROR: ArgumentError: pattern of the matrix changed
 though, an `Error: SingularException` is also possible if the linear solver fails to detect that the sparsity structure changed. To address this issue, you'll need to disable caching the symbolic factorization, e.g.,
 
 ```julia
-solve(prob, Rodas4(linsolve = KLUFactorization(; reuse_symbolic = false)))
+import DifferentialEquations, OrdinaryDiffEq as ODE, LinearSolve
+DE.solve(prob, ODE.Rodas4(linsolve = LinearSolve.KLUFactorization(; reuse_symbolic = false)))
 ```
 
 For more details about possible linear solvers, consult the [LinearSolve.jl documentation](https://docs.sciml.ai/LinearSolve/stable/)

docs/src/basics/problem.md

@@ -69,12 +69,12 @@ which outputs a tuple.
 
 ```@example problem
 import DifferentialEquations
-prob = DifferentialEquations.ODEProblem((u, p, t) -> u, (p, t0) -> p[1], (p) -> (0.0, p[2]), (2.0, 1.0))
+prob = DE.ODEProblem((u, p, t) -> u, (p, t0) -> p[1], (p) -> (0.0, p[2]), (2.0, 1.0))
 ```
 
 ```@example problem
 import Distributions
-prob = DifferentialEquations.ODEProblem((u, p, t) -> u, (p, t) -> Distributions.Normal(p, 1), (0.0, 1.0), 1.0)
+prob = DE.ODEProblem((u, p, t) -> u, (p, t) -> Distributions.Normal(p, 1), (0.0, 1.0), 1.0)
 ```
 
 ## Lower Level `__init` and `__solve`
@@ -101,8 +101,8 @@ example, to simulate it for longer timespan.  It can be done by the
 `remake` function:
 
 ```@example problem
-prob1 = DifferentialEquations.ODEProblem((u, p, t) -> u / 2, 1.0, (0.0, 1.0))
-prob2 = DifferentialEquations.remake(prob1; tspan = (0.0, 2.0))
+prob1 = DE.ODEProblem((u, p, t) -> u / 2, 1.0, (0.0, 1.0))
+prob2 = DE.remake(prob1; tspan = (0.0, 2.0))
 ```
 
 A general syntax of `remake` is

docs/src/examples/beeler_reuter.md

@@ -667,6 +667,6 @@ Plots.heatmap(sol.u[end])
 We achieve around a 6x speedup with running the explicit portion of our IMEX solver on a GPU. The major bottleneck of this technique is the communication between CPU and GPU. In its current form, not all the internals of the method utilize GPU acceleration. In particular, the implicit equations solved by GMRES are performed on the CPU. This partial CPU nature also increases the amount of data transfer that is required between the GPU and CPU (performed every f call). Compiling the full ODE solver to the GPU would solve both of these issues and potentially give a much larger speedup. [JuliaDiffEq developers are currently working on solutions to alleviate these issues](http://www.stochasticlifestyle.com/solving-systems-stochastic-pdes-using-gpus-julia/), but these will only be compatible with native Julia solvers (and not Sundials).
 
 ```julia, echo = false, skip="notebook"
-using SciMLTutorials
+import SciMLTutorials
 SciMLTutorials.tutorial_footer(WEAVE_ARGS[:folder], WEAVE_ARGS[:file])
 ```

docs/src/extras/timestepping.md

@@ -218,5 +218,6 @@ end
 and used via
 
 ```julia
-sol = solve(prob, EM(), dt = dt, adaptive = true, controller = CustomController())
+# Assuming: import DifferentialEquations as DE
+sol = DE.solve(prob, DE.EM(), dt = dt, adaptive = true, controller = CustomController())
 ```

docs/src/features/callback_functions.md

@@ -85,8 +85,8 @@ u0 = [10.0]
 const V = 1
 prob = DE.ODEProblem(f, u0, (0.0, 10.0))
 sol = DE.solve(prob, DE.Tsit5())
-using Plots;
-plot(sol);
+import Plots;
+Plots.plot(sol);
 ```
 
 Now assume we wish to give the patient a dose of 10 at time `t==4`. For this,
@@ -102,7 +102,7 @@ If we then solve with this callback enabled, we see no change:
 
 ```@example callback1
 sol = DE.solve(prob, DE.Tsit5(), callback = cb)
-plot(sol)
+Plots.plot(sol)
 ```
 
 The reason there is no change is because the `DiscreteCallback` only applies at
@@ -112,7 +112,7 @@ We can do that with the `tstops` argument:
 
 ```@example callback1
 sol = DE.solve(prob, DE.Tsit5(), callback = cb, tstops = [4.0])
-plot(sol)
+Plots.plot(sol)
 ```
 
 and thus we achieve the desired result.
@@ -126,7 +126,7 @@ condition(u, t, integrator) = t ∈ dosetimes
 affect!(integrator) = integrator.u[1] += 10
 cb = DE.DiscreteCallback(condition, affect!)
 sol = DE.solve(prob, DE.Tsit5(), callback = cb, tstops = dosetimes)
-plot(sol)
+Plots.plot(sol)
 ```
 
 We can then use this mechanism to make the model arbitrarily complex. For
@@ -140,7 +140,7 @@ condition(u, t, integrator) = t ∈ dosetimes && (u[1] < 1.0)
 affect!(integrator) = integrator.u[1] += 10integrator.t
 cb = DE.DiscreteCallback(condition, affect!)
 sol = DE.solve(prob, DE.Tsit5(), callback = cb, tstops = dosetimes)
-plot(sol)
+Plots.plot(sol)
 ```
 
 #### PresetTimeCallback
@@ -156,7 +156,7 @@ dosetimes = [4.0, 8.0]
 affect!(integrator) = integrator.u[1] += 10
 cb = DE.PresetTimeCallback(dosetimes, affect!)
 sol = DE.solve(prob, DE.Tsit5(), callback = cb)
-plot(sol)
+Plots.plot(sol)
 ```
 
 Notice that this version will automatically set the `tstops` for you.
@@ -237,8 +237,8 @@ Lastly we solve the problem. Note that we must pass `tstop` values of `5.0` and
 ```@example callback2
 const tstop = [5.0; 8.0]
 sol = DE.solve(prob, DE.Tsit5(), callback = cbs, tstops = tstop)
-using Plots;
-plot(sol);
+import Plots;
+Plots.plot(sol);
 ```
 
 It's clear from the plot how the controls affected the outcome.
@@ -382,8 +382,8 @@ tspan = (0.0, 15.0)
 p = 9.8
 prob = DE.ODEProblem(f, u0, tspan, p)
 sol = DE.solve(prob, DE.Tsit5(), callback = cb)
-using Plots;
-plot(sol);
+import Plots;
+Plots.plot(sol);
 ```
 
 As you can see from the resulting image, DifferentialEquations.jl is smart enough
@@ -400,7 +400,7 @@ u0 = [50.0, 0.0]
 tspan = (0.0, 100.0)
 prob = DE.ODEProblem(f, u0, tspan, p)
 sol = DE.solve(prob, DE.Tsit5(), callback = cb)
-plot(sol)
+Plots.plot(sol)
 ```
 
 #### Handling Changing Dynamics and Exactness
@@ -424,7 +424,7 @@ u0 = [1.0, 0.0]
 p = [1.0]
 prob = DE.ODEProblem{true}(dynamics!, u0, (0.0, 1.75), p)
 sol = DE.solve(prob, DE.Tsit5(), callback = floor_event)
-plot(sol)
+Plots.plot(sol)
 ```
 
 Notice that at the end, the ball is not at `0.0` like the condition would let
@@ -494,7 +494,7 @@ u0 = [1.0, 0.0]
 p = [0.0, 0.0]
 prob = ODEProblem{true}(dynamics!, u0, (0.0, 2.0), p)
 sol = solve(prob, Tsit5(), callback = floor_event)
-plot(sol)
+Plots.plot(sol)
 ```
 
 From the readout, we can see the ball only bounced 8 times before it went below
@@ -555,19 +555,19 @@ u0 = [1.0, 0.0]
 p = [1.0, 0.0, 0.0]
 prob = DE.ODEProblem{true}(dynamics!, u0, (0.0, 2.0), p)
 sol = DE.solve(prob, DE.Tsit5(), callback = floor_event)
-plot(sol)
+Plots.plot(sol)
 ```
 
 With this corrected version, we see that after 41 bounces, the accumulation
 point is reached at `t = 1.355261854357056`. To really see the accumulation,
 let's zoom in:
 
 ```@example callback4
-p1 = plot(sol, idxs = 1, tspan = (1.25, 1.40))
-p2 = plot(sol, idxs = 1, tspan = (1.35, 1.36))
-p3 = plot(sol, idxs = 1, tspan = (1.354, 1.35526))
-p4 = plot(sol, idxs = 1, tspan = (1.35526, 1.35526185))
-plot(p1, p2, p3, p4)
+p1 = Plots.plot(sol, idxs = 1, tspan = (1.25, 1.40))
+p2 = Plots.plot(sol, idxs = 1, tspan = (1.35, 1.36))
+p3 = Plots.plot(sol, idxs = 1, tspan = (1.354, 1.35526))
+p4 = Plots.plot(sol, idxs = 1, tspan = (1.35526, 1.35526185))
+Plots.plot(p1, p2, p3, p4)
 ```
 
 I think Zeno would be proud of our solution.
@@ -614,8 +614,8 @@ condition(u, t, integrator) = u[2]
 affect!(integrator) = DE.terminate!(integrator)
 cb = DE.ContinuousCallback(condition, affect!)
 sol = DE.solve(prob, DE.Tsit5(), callback = cb)
-using Plots;
-plot(sol);
+import Plots;
+Plots.plot(sol);
 ```
 
 Note that this uses rootfinding to approximate the “exact” moment of the crossing.
@@ -642,7 +642,7 @@ condition(u, t, integrator) = u[2]
 affect!(integrator) = DE.terminate!(integrator)
 cb = DE.ContinuousCallback(condition, nothing, affect!)
 sol = DE.solve(prob, DE.Tsit5(), callback = cb)
-plot(sol)
+Plots.plot(sol)
 ```
 
 Notice that passing only one `affect!` is the same as
@@ -716,8 +716,8 @@ many cells there are at each time. Since these are discrete values, we calculate
 and plot them directly:
 
 ```@example callback5
-using Plots
-plot(sol.t, map((x) -> length(x), sol[:]), lw = 3,
+import Plots
+Plots.plot(sol.t, map((x) -> length(x), sol[:]), lw = 3,
     ylabel = "Number of Cells", xlabel = "Time")
 ```
 
@@ -726,7 +726,7 @@ plot of the concentration of cell 1 over time. This is done with the command:
 
 ```@example callback5
 ts = range(0, stop = 10, length = 100)
-plot(ts, map((x) -> x[1], sol.(ts)), lw = 3,
+Plots.plot(ts, map((x) -> x[1], sol.(ts)), lw = 3,
     ylabel = "Amount of X in Cell 1", xlabel = "Time")
 ```
 
@@ -786,6 +786,6 @@ tspan = (0.0, 15.0)
 p = 9.8
 prob = DE.ODEProblem(f, u0, tspan, p)
 sol = DE.solve(prob, DE.Tsit5(), callback = cb, dt = 1e-3, adaptive = false)
-using Plots;
-plot(sol, idxs = (1, 3));
+import Plots;
+Plots.plot(sol, idxs = (1, 3));
 ```

docs/src/features/ensemble.md

@@ -271,11 +271,11 @@ achieved with
 [`@everywhere` macro](https://docs.julialang.org/en/v1.2/stdlib/Distributed/#Distributed.@everywhere):
 
 ```julia
-using Distributed
+import Distributed
 import DifferentialEquations as DE
-using Plots
+import Plots
 
-addprocs()
+Distributed.addprocs()
 @everywhere import DifferentialEquations as DE
 ```
 
@@ -308,7 +308,7 @@ sim = DE.solve(ensemble_prob, DE.Tsit5(), DE.EnsembleDistributed(), trajectories
 We can use the plot recipe to plot what the 10 ODEs look like:
 
 ```julia
-plot(sim, linealpha = 0.4)
+Plots.plot(sim, linealpha = 0.4)
 ```
 
 We note that if we wanted to find out what the initial condition was for a given
@@ -335,8 +335,8 @@ function prob_func(prob, i, repeat)
 end
 ensemble_prob = DE.EnsembleProblem(prob, prob_func = prob_func)
 sim = DE.solve(ensemble_prob, DE.Tsit5(), DE.EnsembleThreads(), trajectories = 10)
-using Plots;
-plot(sim);
+import Plots;
+Plots.plot(sim);
 ```
 
 The number of threads to be used has to be defined outside of Julia, in
@@ -415,9 +415,9 @@ Now we solve the problem 10 times and plot all of the trajectories in phase spac
 ```@example ensemble2
 ensemble_prob = DE.EnsembleProblem(prob, prob_func = prob_func)
 sim = DE.solve(ensemble_prob, DE.SRIW1(), trajectories = 10)
-using Plots;
-plot(sim, linealpha = 0.6, color = :blue, idxs = (0, 1), title = "Phase Space Plot");
-plot!(sim, linealpha = 0.6, color = :red, idxs = (0, 2), title = "Phase Space Plot")
+import Plots;
+Plots.plot(sim, linealpha = 0.6, color = :blue, idxs = (0, 1), title = "Phase Space Plot");
+Plots.plot!(sim, linealpha = 0.6, color = :red, idxs = (0, 2), title = "Phase Space Plot")
 ```
 
 We can then summarize this information with the mean/variance bounds using a
@@ -426,7 +426,7 @@ units and directly plot the summary:
 
 ```@example ensemble2
 summ = DE.EnsembleSummary(sim, 0:0.1:10)
-plot(summ, fillalpha = 0.5)
+Plots.plot(summ, fillalpha = 0.5)
 ```
 
 Note that here we used the quantile bounds, which default to `[0.05,0.95]` in
@@ -463,10 +463,10 @@ batch, and declare convergence if the standard error of the mean is calculated
 as sufficiently small:
 
 ```@example ensemble3
-using Statistics
+import Statistics
 function reduction(u, batch, I)
     u = append!(u, batch)
-    finished = (var(u) / sqrt(last(I))) / mean(u) < 0.5
+    finished = (Statistics.var(u) / sqrt(last(I))) / Statistics.mean(u) < 0.5
     u, finished
 end
 ```
@@ -589,19 +589,19 @@ the differential equation, this can get messy, so let's only plot the
 3rd component:
 
 ```@example ensemble4
-using Plots;
-plot(summ; idxs = 3);
+import Plots;
+Plots.plot(summ; idxs = 3);
 ```
 
 We can change to errorbars instead of ribbons and plot two different
 indices:
 
 ```@example ensemble4
-plot(summ; idxs = (3, 5), error_style = :bars)
+Plots.plot(summ; idxs = (3, 5), error_style = :bars)
 ```
 
 Or we can simply plot the mean of every component over time:
 
 ```@example ensemble4
-plot(summ; error_style = :none)
+Plots.plot(summ; error_style = :none)
 ```