Use explicit imports

Author: ChrisRackauckas

docs/src/api/daskr.md

@@ -7,7 +7,7 @@ algorithm, you will need to install and use the package:
 ```julia
 using Pkg
 Pkg.add("DASKR")
-using DASKR
+import DASKR
 ```
 
 These methods can be used independently of the rest of DifferentialEquations.jl.

docs/src/api/sundials.md

@@ -7,7 +7,7 @@ the package before using these solvers:
 ```julia
 using Pkg
 Pkg.add("Sundials")
-using Sundials
+import Sundials
 ```
 
 These methods can be used independently of the rest of DifferentialEquations.jl.

docs/src/basics/faq.md

@@ -250,7 +250,7 @@ ccall((:openblas_get_num_threads64_, Base.libblas_name), Cint, ())
 If I want to set this directly to 4 threads, I would use:
 
 ```julia
-using LinearAlgebra
+import LinearAlgebra
 LinearAlgebra.BLAS.set_num_threads(4)
 ```
 
@@ -260,7 +260,7 @@ can use [MKL.jl](https://github.com/JuliaLinearAlgebra/MKL.jl), which will accel
 the linear algebra routines. This is done via:
 
 ```julia
-using MKL
+import MKL
 ```
 
 #### My ODE is solving really slow
@@ -472,7 +472,7 @@ To show this in action, let's say we want to find the Jacobian of solution
 of the Lotka-Volterra equation at `t=10` with respect to the parameters.
 
 ```@example faq1
-using DifferentialEquations
+import DifferentialEquations
 function func(du, u, p, t)
     du[1] = p[1] * u[1] - p[2] * u[1] * u[2]
     du[2] = -3 * u[2] + u[1] * u[2]
@@ -491,14 +491,14 @@ for the timespan just to show what you'd do if there were parameters-dependent e
 Then we can take the Jacobian via ForwardDiff.jl:
 
 ```@example faq1
-using ForwardDiff
+import ForwardDiff
 ForwardDiff.jacobian(f, [1.5, 1.0])
 ```
 
 and compare it to FiniteDiff.jl:
 
 ```@example faq1
-using FiniteDiff
+import FiniteDiff
 FiniteDiff.finite_difference_jacobian(f, [1.5, 1.0])
 ```
 
@@ -508,7 +508,7 @@ 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
-using LinearAlgebra, OrdinaryDiffEq
+import LinearAlgebra, OrdinaryDiffEq
 function foo(du, u, (A, tmp), t)
     mul!(tmp, A, u)
     @. du = u + tmp
@@ -539,7 +539,7 @@ We could use `get_tmp` and `dualcache` functions from
 to solve this issue, e.g.,
 
 ```julia
-using LinearAlgebra, OrdinaryDiffEq, PreallocationTools
+import LinearAlgebra, OrdinaryDiffEq, PreallocationTools
 function foo(du, u, (A, tmp), t)
     tmp = get_tmp(tmp, first(u) * t)
     mul!(tmp, A, u)

docs/src/basics/integrator.md

@@ -250,7 +250,7 @@ For example, if one wants to iterate but only stop at specific values, one can
 choose:
 
 ```julia
-integrator = init(prob, Tsit5(); dt = 1 // 2^(4), tstops = [0.5], advance_to_tstop = true)
+integrator = DE.init(prob, DE.Tsit5(); dt = 1 // 2^(4), tstops = [0.5], advance_to_tstop = true)
 for (u, t) in tuples(integrator)
     @test t ∈ [0.5, 1.0]
 end
@@ -261,7 +261,7 @@ and thus there are two values of `tstops` which are hit). Additionally, one can
 `solve!` only to `0.5` via:
 
 ```julia
-integrator = init(prob, Tsit5(); dt = 1 // 2^(4), tstops = [0.5])
+integrator = DE.init(prob, DE.Tsit5(); dt = 1 // 2^(4), tstops = [0.5])
 integrator.opts.stop_at_next_tstop = true
 solve!(integrator)
 ```
@@ -283,20 +283,20 @@ For an example of manually chaining together the iterator interface and plotting
 one should try the following:
 
 ```julia
-using DifferentialEquations, DiffEqProblemLibrary, Plots
+import DifferentialEquations as DE, DiffEqProblemLibrary, Plots
 
 # Linear ODE which starts at 0.5 and solves from t=0.0 to t=1.0
-prob = ODEProblem((u, p, t) -> 1.01u, 0.5, (0.0, 1.0))
+prob = DE.ODEProblem((u, p, t) -> 1.01u, 0.5, (0.0, 1.0))
 
-using Plots
-integrator = init(prob, Tsit5(); dt = 1 // 2^(4), tstops = [0.5])
+import Plots
+integrator = DE.init(prob, DE.Tsit5(); dt = 1 // 2^(4), tstops = [0.5])
 pyplot(show = true)
-plot(integrator)
+Plots.plot(integrator)
 for i in integrator
-    display(plot!(integrator, idxs = (0, 1), legend = false))
+    display(Plots.plot!(integrator, idxs = (0, 1), legend = false))
 end
 step!(integrator);
-plot!(integrator, idxs = (0, 1), legend = false);
+Plots.plot!(integrator, idxs = (0, 1), legend = false);
 savefig("iteratorplot.png")
 ```
 

docs/src/basics/plot.md

@@ -8,8 +8,8 @@ and the plotter will generate appropriate plots.
 
 ```julia
 #]add Plots # You need to install Plots.jl before your first time using it!
-using Plots
-plot(sol) # Plots the solution
+import Plots
+Plots.plot(sol) # Plots the solution
 ```
 
 Many of the types defined in the DiffEq universe, such as
@@ -21,7 +21,7 @@ on the plot by doing:
 
 ```julia
 gr()
-plot(sol, title = "I Love DiffEqs!")
+Plots.plot(sol, title = "I Love DiffEqs!")
 ```
 
 Then to save the plot, use `savefig`, for example:
@@ -37,13 +37,13 @@ to use the dense function for generating the plot, and `plotdensity` is the numb
 of evenly-spaced points (in time) to plot. For example:
 
 ```julia
-plot(sol, denseplot = false)
+Plots.plot(sol, denseplot = false)
 ```
 
 means “only plot the points which the solver stepped to”, while:
 
 ```julia
-plot(sol, plotdensity = 1000)
+Plots.plot(sol, plotdensity = 1000)
 ```
 
 means to plot 1000 points using the dense function (since `denseplot=true` by
@@ -133,7 +133,7 @@ more details on the extra controls that exist.
 A plotting timespan can be chosen by the `tspan` argument in `plot`. For example:
 
 ```julia
-plot(sol, tspan = (0.0, 40.0))
+Plots.plot(sol, tspan = (0.0, 40.0))
 ```
 
 only plots between `t=0.0` and `t=40.0`. If `denseplot=true` these bounds will be respected
@@ -143,7 +143,7 @@ i.e. no points outside the interval will be plotted.
 ### Example
 
 ```@example plots
-using DifferentialEquations, Plots
+import DifferentialEquations as DE, Plots
 function lorenz(du, u, p, t)
     du[1] = p[1] * (u[2] - u[1])
     du[2] = u[1] * (p[2] - u[3]) - u[2]
@@ -153,28 +153,28 @@ end
 u0 = [1.0, 5.0, 10.0]
 tspan = (0.0, 100.0)
 p = (10.0, 28.0, 8 / 3)
-prob = ODEProblem(lorenz, u0, tspan, p)
-sol = solve(prob)
-xyzt = plot(sol, plotdensity = 10000, lw = 1.5)
-xy = plot(sol, plotdensity = 10000, idxs = (1, 2))
-xz = plot(sol, plotdensity = 10000, idxs = (1, 3))
-yz = plot(sol, plotdensity = 10000, idxs = (2, 3))
-xyz = plot(sol, plotdensity = 10000, idxs = (1, 2, 3))
-plot(plot(xyzt, xyz), plot(xy, xz, yz, layout = (1, 3), w = 1), layout = (2, 1))
+prob = DE.ODEProblem(lorenz, u0, tspan, p)
+sol = DE.solve(prob)
+xyzt = Plots.plot(sol, plotdensity = 10000, lw = 1.5)
+xy = Plots.plot(sol, plotdensity = 10000, idxs = (1, 2))
+xz = Plots.plot(sol, plotdensity = 10000, idxs = (1, 3))
+yz = Plots.plot(sol, plotdensity = 10000, idxs = (2, 3))
+xyz = Plots.plot(sol, plotdensity = 10000, idxs = (1, 2, 3))
+Plots.plot(Plots.plot(xyzt, xyz), Plots.plot(xy, xz, yz, layout = (1, 3), w = 1), layout = (2, 1))
 ```
 
 An example using the functions:
 
 ```@example plots
 f(x, y, z) = (sqrt(x^2 + y^2 + z^2), x)
-plot(sol, idxs = (f, 1, 2, 3))
+Plots.plot(sol, idxs = (f, 1, 2, 3))
 ```
 
 or the norm over time:
 
 ```@example plots
 f(t, x, y, z) = (t, sqrt(x^2 + y^2 + z^2))
-plot(sol, idxs = (f, 0, 1, 2, 3))
+Plots.plot(sol, idxs = (f, 0, 1, 2, 3))
 ```
 
 ## Animations
@@ -205,14 +205,14 @@ use this to plot solutions. For example, in PyPlot, Gadfly, GR, etc., you can
 do the following to plot the timeseries:
 
 ```julia
-plot(sol.t, sol')
+Plots.plot(sol.t, sol')
 ```
 
 since these plot along the columns, and `sol'` has the timeseries along the column.
 Phase plots can be done similarly, for example:
 
 ```julia
-plot(sol[i, :], sol[j, :], sol[k, :])
+Plots.plot(sol[i, :], sol[j, :], sol[k, :])
 ```
 
 is a 3D phase plot between variables `i`, `j`, and `k`.
@@ -223,7 +223,7 @@ the interpolation must be done manually. For example:
 ```julia
 n = 101 #number of timepoints
 ts = range(0, stop = 1, length = n)
-plot(sol(ts, idxs = i), sol(ts, idxs = j), sol(ts, idxs = k))
+Plots.plot(sol(ts, idxs = i), sol(ts, idxs = j), sol(ts, idxs = k))
 ```
 
 is the phase space using values `0.01` apart in time.

docs/src/basics/problem.md

@@ -68,13 +68,13 @@ which outputs a tuple.
 ### Examples
 
 ```@example problem
-using DifferentialEquations
-prob = ODEProblem((u, p, t) -> u, (p, t0) -> p[1], (p) -> (0.0, p[2]), (2.0, 1.0))
+import DifferentialEquations
+prob = DifferentialEquations.ODEProblem((u, p, t) -> u, (p, t0) -> p[1], (p) -> (0.0, p[2]), (2.0, 1.0))
 ```
 
 ```@example problem
-using Distributions
-prob = ODEProblem((u, p, t) -> u, (p, t) -> Normal(p, 1), (0.0, 1.0), 1.0)
+import Distributions
+prob = DifferentialEquations.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 = ODEProblem((u, p, t) -> u / 2, 1.0, (0.0, 1.0))
-prob2 = remake(prob1; tspan = (0.0, 2.0))
+prob1 = DifferentialEquations.ODEProblem((u, p, t) -> u / 2, 1.0, (0.0, 1.0))
+prob2 = DifferentialEquations.remake(prob1; tspan = (0.0, 2.0))
 ```
 
 A general syntax of `remake` is

docs/src/examples/beeler_reuter.md

@@ -348,27 +348,27 @@ u0[90:102, 90:102] .= v1;   # a small square in the middle of the domain
 The initial condition is a small square in the middle of the domain.
 
 ```julia
-using Plots
-heatmap(u0)
+import Plots
+Plots.heatmap(u0)
 ```
 
 Next, the problem is defined:
 
 ```julia
-using DifferentialEquations, Sundials
+import DifferentialEquations as DE, Sundials
 
 deriv_cpu = BeelerReuterCpu(u0, 1.0);
-prob = ODEProblem(deriv_cpu, u0, (0.0, 50.0));
+prob = DE.ODEProblem(deriv_cpu, u0, (0.0, 50.0));
 ```
 
 For stiff reaction-diffusion equations, CVODE_BDF from Sundial library is an excellent solver.
 
 ```julia
-@time sol = solve(prob, CVODE_BDF(linear_solver = :GMRES), saveat = 100.0);
+@time sol = DE.solve(prob, Sundials.CVODE_BDF(linear_solver = :GMRES), saveat = 100.0);
 ```
 
 ```julia
-heatmap(sol.u[end])
+Plots.heatmap(sol.u[end])
 ```
 
 ## CPU/GPU Beeler-Reuter Solver
@@ -402,7 +402,7 @@ The key to fast CUDA programs is to minimize CPU/GPU memory transfers and global
 We modify ``BeelerReuterCpu`` into ``BeelerReuterGpu`` by defining the state variables as *CuArray*s instead of standard Julia *Array*s. The name of each variable defined on the GPU is prefixed by *d_* for clarity. Note that $\Delta{v}$ is a temporary storage for the Laplacian and stays on the CPU side.
 
 ```julia
-using CUDA
+import CUDA
 
 mutable struct BeelerReuterGpu <: Function
     t::Float64                  # the last timestep time to calculate Δt
@@ -651,15 +651,15 @@ end
 Ready to test!
 
 ```julia
-using DifferentialEquations, Sundials
+import DifferentialEquations as DE, Sundials
 
 deriv_gpu = BeelerReuterGpu(u0, 1.0);
-prob = ODEProblem(deriv_gpu, u0, (0.0, 50.0));
-@time sol = solve(prob, CVODE_BDF(linear_solver = :GMRES), saveat = 100.0);
+prob = DE.ODEProblem(deriv_gpu, u0, (0.0, 50.0));
+@time sol = DE.solve(prob, Sundials.CVODE_BDF(linear_solver = :GMRES), saveat = 100.0);
 ```
 
 ```julia
-heatmap(sol.u[end])
+Plots.heatmap(sol.u[end])
 ```
 
 ## Summary