strict links

Author: ArnoStrouwen

docs/make.jl

@@ -20,6 +20,14 @@ makedocs(modules = [
              OrdinaryDiffEq,
              Sundials, DASKR,
          ],
+         linkcheck = true,
+         linkcheck_ignore = ["https://www.izhikevich.org/publications/spikes.htm",
+             "https://biojulia.net/post/hardware/",
+             "https://archimede.dm.uniba.it/~testset/report/pollu.pdf",
+             "http://www.radford.edu/~thompson/vodef90web/problems/demosnodislin/Demos_Pitagora/DemoHires/demohires.pdf",
+             "https://www.radford.edu/%7Ethompson/RP/nonnegative.pdf",
+             "http://www.radford.edu/~thompson/vodef90web/problems/demosnodislin/Demos_Pitagora/DemoOrego/demoorego.pdf",
+         ],
          strict = [
              :doctest,
              :linkcheck,
@@ -34,6 +42,7 @@ makedocs(modules = [
                                   canonical = "https://docs.sciml.ai/DiffEqDocs/stable/"),
          sitename = "DifferentialEquations.jl",
          authors = "Chris Rackauckas",
+         draft = true,
          pages = pages)
 
 #Redirect old links

docs/src/basics/faq.md

@@ -191,7 +191,7 @@ algorithms utilize standard arithmetical functions. Both additionally utilize
 the user's norm specified via the common interface options and, if a stiff
 solver, ForwardDiff/DiffEqDiffTools for the Jacobian calculation, and Base linear
 factorizations for the linear solve. For your type, you may likely need to give
-a [better form of the norm](@ref advanced_adaptive_stepsize_control),
+a [better form of the norm](https://docs.sciml.ai/DiffEqDocs/stable/extras/timestepping/#Common-Setup),
 [Jacobian](@ref performance_overloads),
 or [linear solve calculations](@ref linear_nonlinear)
 to fully utilize parallelism.
@@ -238,7 +238,7 @@ LinearAlgebra.BLAS.set_num_threads(4)
 
 Additionally, sometimes Intel's MKL might be a faster BLAS than the standard
 BLAS that ships with Julia (OpenBLAS). To switch your BLAS implementation, you
-can use [MKL.jl](https://github.com/JuliaComputing/MKL.jl), which will accelerate
+can use [MKL.jl](https://github.com/JuliaLinearAlgebra/MKL.jl), which will accelerate
 the linear algebra routines. This is done via:
 
 ```julia
@@ -427,7 +427,7 @@ for longtime integration.
 For conserving energy, there are a few things you can do. First of all, the energy
 error is related to the integration error, so simply solving with higher accuracy
 will reduce the error. The results in the
-[DiffEqBenchmarks](https://github.com/SciML/DiffEqBenchmarks.jl) show
+[DiffEqBenchmarks](https://github.com/SciML/SciMLBenchmarks.jl) show
 that using a `DPRKN` method with low tolerance can be a great choice. Another
 thing you can do is use
 [the ManifoldProjection callback from the callback library](@ref callback_library).
@@ -555,7 +555,7 @@ though, an `Error: SingularException` is also possible if the linear solver fail
 solve(prob, Rodas4(linsolve = KLUFactorization(; reuse_symbolic = false)))
 ```
 
-For more details about possible linear solvers, consult the [LinearSolve.jl documentation](http://linearsolve.sciml.ai/dev/)
+For more details about possible linear solvers, consult the [LinearSolve.jl documentation](https://docs.sciml.ai/LinearSolve/stable/)
 
 ## Odd Error Messages
 

docs/src/basics/overview.md

@@ -86,10 +86,10 @@ finalized results to large audiences. The tools for algorithm development allow
 easy convergence testing, benchmarking, and higher order analysis (stability plotting,
 etc.). This is one of the reasons why DifferentialEquations.jl contains many algorithms
 which are unique and the results of recent publications! Please check out the
-[developer documentation](https://devdocs.sciml.ai/dev/)
+[developer documentation](https://docs.sciml.ai/DiffEqDevDocs/stable/)
 for more information on using the development tools.
 
 Note that DifferentialEquations.jl allows for distributed development, meaning that
 algorithms which “plug-into the ecosystem” don't have to be a part of the major packages.
-If you are interested in adding your work to the ecosystem, checkout the [developer documentation](https://devdocs.sciml.ai/dev/)
+If you are interested in adding your work to the ecosystem, checkout the [developer documentation](https://docs.sciml.ai/DiffEqDevDocs/stable/)
 for more information.

docs/src/basics/plot.md

@@ -15,7 +15,7 @@ plot(sol) # Plots the solution
 Many of the types defined in the DiffEq universe, such as
 `ODESolution`, `ConvergenceSimulation` `WorkPrecision`, etc. have plot recipes
 to handle the default plotting behavior. Plots can be customized using
-[all the keyword arguments provided by Plots.jl](http://docs.juliaplots.org/dev/supported/).
+[all the keyword arguments provided by Plots.jl](https://docs.juliaplots.org/stable/generated/attributes_plot/).
 For example, we can change the plotting backend to the GR package and put a title
 on the plot by doing:
 
@@ -196,7 +196,7 @@ saves every 4th frame via:
 animate(sol, lw = 3, every = 4)
 ```
 
-Please see [Plots.jl's documentation](https://juliaplots.github.io/) for more information
+Please see [Plots.jl's documentation](https://juliaplots.org/) for more information
 on the available attributes.
 
 ## Plotting Without the Plot Recipe

docs/src/examples/beeler_reuter.md

@@ -4,7 +4,7 @@
 
 [SciML](https://github.com/SciML) is a suite of optimized Julia libraries to solve ordinary differential equations (ODE). *SciML* provides many explicit and implicit solvers suited for different types of ODE problems. It is possible to reduce a system of partial differential equations into an ODE problem by employing the [method of lines (MOL)](https://en.wikipedia.org/wiki/Method_of_lines). The essence of MOL is to discretize the spatial derivatives (by finite difference, finite volume or finite element methods) into algebraic equations and to keep the time derivatives as is. The resulting differential equations are left with only one independent variable (time) and can be solved with an ODE solver. [Solving Systems of Stochastic PDEs and using GPUs in Julia](http://www.stochasticlifestyle.com/solving-systems-stochastic-pdes-using-gpus-julia/) is a brief introduction to MOL and using GPUs to accelerate PDE solving in *JuliaDiffEq*. Here we expand on this introduction by developing an implicit/explicit (IMEX) solver for a 2D cardiac electrophysiology model and show how to use [CUDA](https://github.com/JuliaGPU/CUDA.jl) libraries to run the explicit part of the model on a GPU.
 
-Note that this tutorial does not use the [higher order IMEX methods built into DifferentialEquations.jl](https://docs.sciml.ai/latest/solvers/split_ode_solve/#Implicit-Explicit-(IMEX)-ODE-1), but instead shows how to hand-split an equation when the explicit portion has an analytical solution (or approximate), which is common in many scenarios.
+Note that this tutorial does not use the [higher order IMEX methods built into DifferentialEquations.jl](https://docs.sciml.ai/DiffEqDocs/stable/solvers/split_ode_solve/#Implicit-Explicit-(IMEX)-ODE), but instead shows how to hand-split an equation when the explicit portion has an analytical solution (or approximate), which is common in many scenarios.
 
 There are hundreds of ionic models that describe cardiac electrical activity in various degrees of detail. Most are based on the classic [Hodgkin-Huxley model](https://en.wikipedia.org/wiki/Hodgkin%E2%80%93Huxley_model) and define the time-evolution of different state variables in the form of nonlinear first-order ODEs. The state vector for these models includes the transmembrane potential, gating variables, and ionic concentrations. The coupling between cells is through the transmembrane potential only and is described as a reaction-diffusion equation, which is a parabolic PDE,
 
@@ -24,7 +24,7 @@ We have chosen the [Beeler-Reuter ventricular ionic model](https://www.ncbi.nlm.
 
 ## CPU-Only Beeler-Reuter Solver
 
-Let's start by developing a CPU only IMEX solver. The main idea is to use the *DifferentialEquations* framework to handle the implicit part of the equation and code the analytical approximation for the explicit part separately. If no analytical approximation was known for the explicit part, one could use methods from [this list](https://docs.sciml.ai/latest/solvers/split_ode_solve/#Implicit-Explicit-(IMEX)-ODE-1).
+Let's start by developing a CPU only IMEX solver. The main idea is to use the *DifferentialEquations* framework to handle the implicit part of the equation and code the analytical approximation for the explicit part separately. If no analytical approximation was known for the explicit part, one could use methods from [this list](https://docs.sciml.ai/DiffEqDocs/stable/solvers/split_ode_solve/#Implicit-Explicit-(IMEX)-ODE).
 
 First, we define the model constants:
 
@@ -90,7 +90,7 @@ end
 
 ### Laplacian
 
-The finite-difference Laplacian is calculated in-place by a 5-point stencil. The Neumann boundary condition is enforced. Note that we could have also used [DiffEqOperators.jl](https://github.com/JuliaDiffEq/DiffEqOperators.jl) to automate this step.
+The finite-difference Laplacian is calculated in-place by a 5-point stencil. The Neumann boundary condition is enforced. Note that we could have also used [DiffEqOperators.jl](https://docs.sciml.ai/DiffEqDocs/stable/features/diffeq_operator/#DiffEqOperators) to automate this step.
 
 ```julia
 # 5-point stencil
@@ -127,7 +127,7 @@ end
 
 ### The Rush-Larsen Method
 
-We use an explicit solver for all the state variables except for the transmembrane potential, which is solved with the help of an implicit solver. The explicit solver is a domain-specific exponential method, the Rush-Larsen method. This method utilizes an approximation on the model in order to transform the IMEX equation into a form suitable for an implicit ODE solver. This combination of implicit and explicit methods forms a specialized IMEX solver. For general IMEX integration, please see the [IMEX solvers documentation](https://docs.sciml.ai/latest/solvers/split_ode_solve/#Implicit-Explicit-(IMEX)-ODE-1). While we could have used the general model to solve the current problem, for this specific model, the transformation approach is more efficient and is of practical interest.
+We use an explicit solver for all the state variables except for the transmembrane potential, which is solved with the help of an implicit solver. The explicit solver is a domain-specific exponential method, the Rush-Larsen method. This method utilizes an approximation on the model in order to transform the IMEX equation into a form suitable for an implicit ODE solver. This combination of implicit and explicit methods forms a specialized IMEX solver. For general IMEX integration, please see the [IMEX solvers documentation](https://docs.sciml.ai/DiffEqDocs/stable/solvers/split_ode_solve/#Implicit-Explicit-(IMEX)-ODE). While we could have used the general model to solve the current problem, for this specific model, the transformation approach is more efficient and is of practical interest.
 
 The [Rush-Larsen](https://ieeexplore.ieee.org/document/4122859/) method replaces the explicit Euler integration for the gating variables with direct integration. The starting point is the general ODE for the gating variables in Hodgkin-Huxley style ODEs,
 

docs/src/features/ensemble.md

@@ -132,7 +132,7 @@ components of the solution to plot. For example, if the differential equation
 is a vector of 9 values, `idxs=1:2:9` will plot only the solutions
 of the odd components. Another additional argument is `zcolors` (an alias of `marker_z`) which allows
 you to pass a `zcolor` for each series. For details about `zcolor` see the
-[Series documentation for Plots.jl](http://docs.juliaplots.org/dev/attributes/).
+[Series documentation for Plots.jl](https://docs.juliaplots.org/stable/attributes/).
 
 ## Analyzing an Ensemble Experiment
 

docs/src/features/io.md

@@ -6,7 +6,7 @@ existing functionality for doing so.
 
 ## Tabular Data: IterableTables
 
-An interface to [IterableTables.jl](https://github.com/davidanthoff/IterableTables.jl)
+An interface to [IterableTables.jl](https://github.com/queryverse/IterableTables.jl)
 is provided. This IterableTables link allows you to use a solution
 type as the data source to convert to other tabular data formats. For example,
 let's solve a 4x2 system of ODEs and get the DataFrame:

docs/src/features/linear_nonlinear.md

@@ -15,14 +15,14 @@ details how to make that choice.
     These options do not apply to the Sundials differential equation solvers
     (`CVODE_BDF`, `CVODE_Adams`, `ARKODE`, and `IDA`). For complete descriptions
     of similar functionality for Sundials, see the
-    [Sundials ODE solver documentation](@id ode_solve_sundials) and
-    [Sundials DAE solver documentation](@id dae_solve_sundials).
+    [Sundials ODE solver documentation](@ref ode_solve_sundials) and
+    [Sundials DAE solver documentation](@ref dae_solve_sundials).
 
 ## Linear Solvers: `linsolve` Specification
 
 For linear solvers, DifferentialEquations.jl uses
 [LinearSolve.jl](https://github.com/SciML/LinearSolve.jl). Any
-[LinearSolve.jl algorithm](http://linearsolve.sciml.ai/dev/solvers/solvers/)
+[LinearSolve.jl algorithm](https://linearsolve.sciml.ai/dev/solvers/solvers/)
 can be used as the linear solver simply by passing the algorithm choice to
 linsolve. For example, the following tells `TRBDF2` to use [KLU.jl](https://github.com/JuliaSparse/KLU.jl)
 
@@ -31,12 +31,12 @@ TRBDF2(linsolve = KLUFactorization())
 ```
 
 Many choices exist, including GPU offloading, so consult the
-[LinearSolve.jl documentation](http://linearsolve.sciml.ai/dev/) for more details
+[LinearSolve.jl documentation](https://linearsolve.sciml.ai/dev/) for more details
 on the choices.
 
 ## Preconditioners: `precs` Specification
 
-Any [LinearSolve.jl-compatible preconditioner](http://linearsolve.sciml.ai/dev/basics/Preconditioners/)
+Any [LinearSolve.jl-compatible preconditioner](https://docs.sciml.ai/LinearSolve/stable/basics/Preconditioners/)
 can be used as a left or right preconditioner. Preconditioners are specified by
 the `Pl,Pr = precs(W,du,u,p,t,newW,Plprev,Prprev,solverdata)` function where
 the arguments are defined as:

docs/src/features/low_dep.md

@@ -29,7 +29,7 @@ following choices:
     running long computations, such as in optimization loops.
 
 For more information on the specialization levels, please see
-[the SciMLBase documentation on specialization levels](https://scimlbase.sciml.ai/stable/interfaces/Problems/#Specialization-Levels).
+[the SciMLBase documentation on specialization levels](https://docs.sciml.ai/SciMLBase/stable/interfaces/Problems/#Specialization-Levels).
 
 DifferentialEquations.jl and its ODE package OrdinaryDiffEq.jl precompile
 some standard problem types and solvers. The problem types include the

docs/src/getting_started.md

@@ -225,7 +225,7 @@ using Plots
 plot(sol)
 ```
 
-The plot function can be formatted using [the attributes available in Plots.jl](https://juliaplots.github.io/).
+The plot function can be formatted using [the attributes available in Plots.jl](https://juliaplots.org/).
 Additional DiffEq-specific controls are documented [at the plotting page](@ref plot).
 
 For example, from the Plots.jl attribute page, we see that the line width can be