Update 01-workshop_exercises.jmd

Author: ChrisRackauckas

tutorials/exercises/01-workshop_exercises.jmd

@@ -66,7 +66,7 @@ $$\begin{align}
 
 with parameter values $s=77.27$, $w=0.161$, and $q=8.375 \times 10^{-6}$, and
 initial conditions $x(0)=1$, $y(0)=2$, and $z(0)=3$. Use
-[the tutorial on solving ODEs](http://docs.juliadiffeq.org/latest/tutorials/ode_example.html)
+[the tutorial on solving ODEs](http://docs.juliadiffeq.org/dev/tutorials/ode_example.html)
 to solve this differential equation on the
 timespan of $t\in[0,360]$ with the default ODE solver. To investigate the result,
 plot the solution of all components over time, and plot the phase space plot of
@@ -77,7 +77,7 @@ the solution (hint: use `vars=(1,2,3)`). What shape is being drawn in phase spac
 Because the reaction rates of `q` vs `s` is very large, this model has a "fast"
 system and a "slow" system. This is typical of ODEs which exhibit a property
 known as stiffness. Stiffness changes the ODE solvers which can handle the
-equation well. [Take a look at the ODE solver page](http://docs.juliadiffeq.org/latest/solvers/ode_solve.html)
+equation well. [Take a look at the ODE solver page](http://docs.juliadiffeq.org/dev/solvers/ode_solve.html)
 and investigate solving the equation using methods for non-stiff equations
 (ex: `Tsit5`) and stiff equations (ex: `Rodas5`).
 
@@ -92,7 +92,7 @@ the Jacobian is costly, and thus it can be beneficial to provide the analytical
 solution.
 
 Use the
-[ODEFunction definition page](http://docs.juliadiffeq.org/latest/features/performance_overloads.html)
+[ODEFunction definition page](http://docs.juliadiffeq.org/dev/features/performance_overloads.html)
 to define an `ODEFunction` which holds both the OREGO ODE and its Jacobian, and solve using `Rodas5`.
 
 ## (Optional) Part 4: Automatic Symbolicification and Analytical Jacobian Calculations
@@ -122,9 +122,9 @@ dz &= w(x - z)dt + \sigma_3 z dW_3\end{align}$$
 
 with $\sigma_i = 0.1$ where the `dW` terms describe a Brownian motion, a
 continuous random process with normally distributed increments. Use the
-[tutorial on solving SDEs](http://docs.juliadiffeq.org/latest/tutorials/sde_example.html)
+[tutorial on solving SDEs](http://docs.juliadiffeq.org/dev/tutorials/sde_example.html)
 to solve simulate this model. Then,
-[use the `EnsembleProblem`](http://docs.juliadiffeq.org/latest/features/ensemble.html)
+[use the `EnsembleProblem`](http://docs.juliadiffeq.org/dev/features/ensemble.html)
 to generate and plot 100 trajectories of the stochastic model, and use
 `EnsembleSummary` to plot the mean and 5%-95% region over time.
 
@@ -154,7 +154,7 @@ B + Z -> Y
 
 where reactions take place at a rate which is propoertional to its components,
 i.e. the first reaction has a rate `k*A*Y` for some `k`.
-Use the [tutorial on Gillespie SSA models](http://docs.juliadiffeq.org/latest/tutorials/discrete_stochastic_example.html)
+Use the [tutorial on Gillespie SSA models](http://docs.juliadiffeq.org/dev/tutorials/discrete_stochastic_example.html)
 to implement the `JumpProblem` for this model, and use the `EnsembleProblem`
 and `EnsembleSummary` to characterize the stochastic trajectories.
 
@@ -176,7 +176,7 @@ data = [1.0 2.05224 2.11422 2.1857 2.26827 2.3641 2.47618 2.60869 2.7677 2.96232
         3.0 2.82065 2.68703 2.58974 2.52405 2.48644 2.47449 2.48686 2.52337 2.58526 2.67563 2.80053 2.9713 3.21051 3.5712 4.23706 12.0266 14868.8 24987.8 23453.4 19202.2 15721.6 12872.0 10538.8 8628.66 7064.73 5784.29 4735.96 3877.66 3174.94 2599.6]
 ```
 
-[Follow the exmaples on the parameter estimation page](http://docs.juliadiffeq.org/latest/analysis/parameter_estimation.html#Bayesian-Methods-1)
+[Follow the exmaples on the parameter estimation page](http://docs.juliadiffeq.org/dev/analysis/parameter_estimation.html#Bayesian-Methods-1)
 to perform a Bayesian parameter estimation. What are the most likely parameters
 for the model given the posterior parameter distributions?
 
@@ -190,7 +190,7 @@ parallelism section for details on how to accelerate this.
 DiffEqBiological.jl is a helper library for the DifferentialEquations.jl
 ecosystem for defining chemical reaction systems at a high leevel for easy
 simulation in these various forms. Use the descrption
-[from the Chemical Reaction Networks documentation page](http://docs.juliadiffeq.org/latest/models/biological.html)
+[from the Chemical Reaction Networks documentation page](http://docs.juliadiffeq.org/dev/models/biological.html)
 to build a reaction network and generate the ODE/SDE/jump equations, and
 compare the result to your handcoded versions.
 
@@ -223,7 +223,7 @@ $$\begin{align}
 
 with $t \in [0,90]$, $u_0 = [100.0,0]$, and $p=[K_a,K_e]=[2.268,0.07398]$.
 
-With this model, use [the event handling documentation page](http://docs.juliadiffeq.org/latest/features/callback_functions.html)
+With this model, use [the event handling documentation page](http://docs.juliadiffeq.org/dev/features/callback_functions.html)
 to define a `DiscreteCallback` which fires at `t ∈ [24,48,72]` and adds a
 dose of 100 into `[Depot]`. (Hint: you'll want to set `tstops=[24,48,72]` to
 force the ODE solver to step at these times).
@@ -241,7 +241,7 @@ $$\begin{align}
 \frac{d[Central]}{dt} &= K_a [Depot](t-\tau) - K_e [Central]\end{align}$$
 
 where the parameter $τ = 6.0$.
-[Use the DDE tutorial](http://docs.juliadiffeq.org/latest/tutorials/dde_example.html)
+[Use the DDE tutorial](http://docs.juliadiffeq.org/dev/tutorials/dde_example.html)
 to define and solve this delayed version of the hybrid model.
 
 ## Part 3: Automatic Differentiation (AD) for Optimization (I)
@@ -254,7 +254,7 @@ do this is via Automatic Differentition (AD). For small numbers of parameters
 we will make use of ForwardDiff.jl to use Dual number arithmetic to retrive
 both the solution and its derivative w.r.t. parameters in a single solve.
 
-[Use the information from the page on local sensitvity analysis](http://docs.juliadiffeq.org/latest/analysis/sensitivity.html)
+[Use the information from the page on local sensitvity analysis](http://docs.juliadiffeq.org/dev/analysis/sensitivity.html)
 to define the input dual numbers, solve the equation, and plot both the solution
 over time and the derivative of the solution w.r.t. the parameters.
 
@@ -268,7 +268,7 @@ data = [100.0 0.246196 0.000597933 0.24547 0.000596251 0.245275 0.000595453 0.24
         0.0 53.7939 16.8784 58.7789 18.3777 59.1879 18.5003 59.2611]
 ```
 
-Use [the parameter estimation page](http://docs.juliadiffeq.org/latest/analysis/parameter_estimation.html)
+Use [the parameter estimation page](http://docs.juliadiffeq.org/dev/analysis/parameter_estimation.html)
 to define a loss function with `build_loss_objective` and optimize the parameters
 against the data. What parameters were used to generate the data?
 
@@ -282,15 +282,15 @@ concentration falls below 25. To model this effect, we will need to use
 `ContinuousCallbacks` to define a callback that triggers when `[Central]` falls
 below the threshold value.
 
-[Use the documentation on the event handling page](http://docs.juliadiffeq.org/latest/features/callback_functions.html) to define such a callback,
+[Use the documentation on the event handling page](http://docs.juliadiffeq.org/dev/features/callback_functions.html) to define such a callback,
 and plot the solution over time. How many times does the auto-doser administer
 a dose? How much does this change as you change the delay time $\tau$?
 
 ## Part 6: Global Sensitivity Analysis with the Morris and Sobol Methods
 
 To understand how the parameters effect the solution in a global sense, one
 wants to use Global Sensitivity Analysis. Use the
-[GSA documentation page](http://docs.juliadiffeq.org/latest/analysis/global_sensitivity.html)
+[GSA documentation page](http://docs.juliadiffeq.org/dev/analysis/global_sensitivity.html)
 perform global sensitivity analysis and quantify the effect of the various
 parameters on the solution.
 
@@ -327,14 +327,14 @@ $$\begin{align}
 
 with $y(0) = [1,0,0]$ and $dy(0) = [-0.04,0.04,0.0]$ using the mass-matrix
 formulation and `Rodas5()`. Use the
-[ODEProblem page](http://docs.juliadiffeq.org/latest/types/ode_types.html)
+[ODEProblem page](http://docs.juliadiffeq.org/dev/types/ode_types.html)
 to find out how to declare a mass matrix.
 
 (Hint: what if the last row has all zeros?)
 
 ## Part 2: Solving the Implicit Robertson Equations with IDA
 
-Use the [DAE Tutorial](http://docs.juliadiffeq.org/latest/tutorials/dae_example.html)
+Use the [DAE Tutorial](http://docs.juliadiffeq.org/dev/tutorials/dae_example.html)
 to define a DAE in its implicit form and solve the Robertson equation with IDA.
 Why is `differential_vars = [true,true,false]`?
 
@@ -455,7 +455,7 @@ your needs.
 
 Use the `sparsity!` function from [SparseDiffTools](https://github.com/JuliaDiffEq/SparseDiffTools.jl)
 to generate the sparsity pattern for the Jacobian of this problem. Follow
-the documentations [on the DiffEqFunction page](http://docs.juliadiffeq.org/latest/features/performance_overloads.html)
+the documentations [on the DiffEqFunction page](http://docs.juliadiffeq.org/dev/features/performance_overloads.html)
 to specify the sparsity pattern of the Jacobian. Generate an add the color
 vector to speed up the computation of the Jacobian.
 
@@ -473,15 +473,15 @@ solve with an analytical sparse Jacobian.
 
 ## Part 6: Utilizing Preconditioned-GMRES Linear Solvers
 
-Use the [linear solver specification page](http://docs.juliadiffeq.org/latest/features/linear_nonlinear.html)
+Use the [linear solver specification page](http://docs.juliadiffeq.org/dev/features/linear_nonlinear.html)
 to solve the equation with `TRBDF2` with GMRES. Use the Sundials documentation
 to solve the equation with `CVODE_BDF` with Sundials' special internal GMRES.
 To both of these, use the [AlgebraicMultigrid.jl](https://github.com/JuliaLinearAlgebra/AlgebraicMultigrid.jl)
 to add a preconditioner to the GMRES solver.
 
 ## Part 7: Exploring IMEX and Exponential Integrator Techniques (E)
 
-Instead of using the standard `ODEProblem`, define a [`SplitODEProblem`](http://docs.juliadiffeq.org/latest/types/split_ode_types.html)
+Instead of using the standard `ODEProblem`, define a [`SplitODEProblem`](http://docs.juliadiffeq.org/dev/types/split_ode_types.html)
 to move some of the equation to the "non-stiff part". Try different splits
 and solve with `KenCarp4` to see if the solution can be accelerated.
 
@@ -514,7 +514,7 @@ where forward sensitivity analysis (forward-mode automatic differentiation)
 is no longer suitable, and for these cases one uses adjoint sensitivity analysis.
 
 Rewrite the PDE so the constant terms are parameters, and use the
-[adjoint sensitivity analysis](http://docs.juliadiffeq.org/latest/analysis/sensitivity.html#Adjoint-Sensitivity-Analysis-1)
+[adjoint sensitivity analysis](http://docs.juliadiffeq.org/dev/analysis/sensitivity.html#Adjoint-Sensitivity-Analysis-1)
 documentation to solve for the solution gradient with a cost function being the
 L2 distance of the solution from the value 1. Solve with interpolated and
 checkpointed adjoints. Play with using reverse-mode automatic differentiation
@@ -549,7 +549,7 @@ Solve this system over the timespan $t\in[0,1000]$
 ## (Optional) Part 2: Alternative Dynamical Implmentations of Henon-Heiles (B)
 
 The Henon-Heiles defines a Hamiltonian system with certain structures which
-can be utilized for a more efficient solution. Use [the Dynamical problems page](http://docs.juliadiffeq.org/latest/types/dynamical_types.html)
+can be utilized for a more efficient solution. Use [the Dynamical problems page](http://docs.juliadiffeq.org/dev/types/dynamical_types.html)
 to define a `SecondOrderODEProblem` corresponding to the acceleration terms:
 
 $$\begin{align}
@@ -568,7 +568,7 @@ Solve this problem using the `HamiltonianProblem` constructor from DiffEqPhysics
 
 To understand the orbits of the Henon-Heiles system, it can be useful to solve
 the system with many different initial conditions. Use the
-[ensemble interface](http://docs.juliadiffeq.org/latest/features/ensemble.html)
+[ensemble interface](http://docs.juliadiffeq.org/dev/features/ensemble.html)
 to solve with randomized initial conditions in parallel using threads with
 `EnsembleThreads()`. Then, use `addprocs()` to add more cores and solve using
 `EnsembleDistributed()`. The former will solve using all of the cores on a