Run examples in docs

Author: baggepinnen

docs/make.jl

@@ -5,6 +5,14 @@ makedocs(
     authors="Chris Rackauckas",
     modules=[ModelingToolkit],
     clean=true,doctest=false,
+    strict=[
+        :doctest, 
+        :linkcheck, 
+        :parse_error,
+        :example_block,
+        # Other available options are
+        # :autodocs_block, :cross_references, :docs_block, :eval_block, :example_block, :footnote, :meta_block, :missing_docs, :setup_block
+    ],
     format=Documenter.HTML(analytics = "UA-90474609-3",
                            assets=["assets/favicon.ico"],
                            canonical="https://mtk.sciml.ai/stable/"),

docs/src/basics/Composition.md

@@ -14,7 +14,7 @@ forcing later. Here, the library author defines a component named
 saying the forcing term of `decay1` is a constant while the forcing term
 of `decay2` is the value of the state variable `x`.
 
-```julia
+```@example composition
 using ModelingToolkit
 
 function decay(;name)
@@ -48,16 +48,11 @@ equations(connected)
 simplified_sys = structural_simplify(connected)
 
 equations(simplified_sys)
-
-#3-element Vector{Equation}:
-# Differential(t)(decay1₊f(t)) ~ 0
-# Differential(t)(decay1₊x(t)) ~ decay1₊f(t) - (decay1₊a*(decay1₊x(t)))
-# Differential(t)(decay2₊x(t)) ~ decay1₊x(t) - (decay2₊a*(decay2₊x(t)))
 ```
 
 Now we can solve the system:
 
-```julia
+```@example composition
 x0 = [
   decay1.x => 1.0
   decay1.f => 0.0
@@ -80,7 +75,7 @@ Every `AbstractSystem` has a `system` keyword argument for specifying
 subsystems. A model is the composition of itself and its subsystems.
 For example, if we have:
 
-```julia
+```@example composition
 @named sys = compose(ODESystem(eqs,indepvar,states,ps),subsys)
 ```
 
@@ -105,7 +100,7 @@ associated `SciMLProblem` type using the standard constructors. When
 this is done, the initial conditions and parameters must be specified
 in their namespaced form. For example:
 
-```julia
+```@example composition
 u0 = [
   x => 2.0
   subsys.x => 2.0
@@ -179,7 +174,7 @@ let's assume we have three separate systems which we want to compose to a single
 one. This is how one could explicitly forward all states and parameters to the
 higher level system:
 
-```julia
+```@example compose
 using ModelingToolkit, OrdinaryDiffEq, Plots
 
 ## Library code
@@ -217,16 +212,13 @@ the parameters are forwarded through a relationship in their default
 values. The user of this model can then solve this model simply by
 specifying the values at the highest level:
 
-```julia
+```@example compose
 sireqn_simple = structural_simplify(sir)
 
 equations(sireqn_simple)
+```
 
-# 3-element Vector{Equation}:
-#Differential(t)(seqn₊S(t)) ~ -seqn₊β*ieqn₊I(t)*seqn₊S(t)*(((ieqn₊I(t)) + (reqn₊R(t)) + (seqn₊S(t)))^-1)
-#Differential(t)(ieqn₊I(t)) ~ ieqn₊β*ieqn₊I(t)*seqn₊S(t)*(((ieqn₊I(t)) + (reqn₊R(t)) + (seqn₊S(t)))^-1) - (ieqn₊γ*(ieqn₊I(t)))
-#Differential(t)(reqn₊R(t)) ~ reqn₊γ*ieqn₊I(t)
-
+```@example compose
 ## User Code
 
 u0 = [seqn.S => 990.0,
@@ -270,7 +262,7 @@ single_state_variable ~ expression_involving_any_variables
 
 ### Example: Friction
 The system below illustrates how this can be used to model Coulomb friction
-```julia
+```@example events
 using ModelingToolkit, OrdinaryDiffEq, Plots
 function UnitMassWithFriction(k; name)
   @variables t x(t)=0 v(t)=0
@@ -290,7 +282,7 @@ plot(sol)
 ### Example: Bouncing ball
 In the documentation for DifferentialEquations, we have an example where a bouncing ball is simulated using callbacks which has an `affect!` on the state. We can model the same system using ModelingToolkit like this
 
-```julia
+```@example events
 @variables t x(t)=1 v(t)=0
 D = Differential(t)
 
@@ -313,7 +305,7 @@ plot(sol)
 
 ### Test bouncing ball in 2D with walls
 Multiple events? No problem! This example models a bouncing ball in 2D that is enclosed by two walls at $y = \pm 1.5$.
-```julia
+```@example events
 @variables t x(t)=1 y(t)=0 vx(t)=0 vy(t)=2
 D = Differential(t)
 

docs/src/mtkitize_tutorials/modelingtoolkitize.md

@@ -4,7 +4,7 @@ For some `DEProblem` types, automatic tracing functionality is already included
 via the `modelingtoolkitize` function. Take, for example, the Robertson ODE
 defined as an `ODEProblem` for DifferentialEquations.jl:
 
-```julia
+```@example mtkize
 using DifferentialEquations
 function rober(du,u,p,t)
   y₁,y₂,y₃ = u
@@ -20,12 +20,12 @@ prob = ODEProblem(rober,[1.0,0.0,0.0],(0.0,1e5),(0.04,3e7,1e4))
 If we want to get a symbolic representation, we can simply call `modelingtoolkitize`
 on the `prob`, which will return an `ODESystem`:
 
-```julia
+```@example mtkize
 sys = modelingtoolkitize(prob)
 ```
 
 Using this, we can symbolically build the Jacobian and then rebuild the ODEProblem:
 
-```julia
+```@example mtkize
 prob_jac = ODEProblem(sys,[],(0.0,1e5),jac=true)
 ```

docs/src/mtkitize_tutorials/modelingtoolkitize_index_reduction.md

@@ -7,7 +7,7 @@ pendulum which accidentally generates an index-3 DAE, and show how to use the
 
 ## Copy-Pastable Example
 
-```julia
+```@example indexred
 using ModelingToolkit
 using LinearAlgebra
 using OrdinaryDiffEq
@@ -55,7 +55,7 @@ As a good DifferentialEquations.jl user, one would follow
 [the mass matrix DAE tutorial](https://diffeq.sciml.ai/stable/tutorials/advanced_ode_example/#Handling-Mass-Matrices)
 to arrive at code for simulating the model:
 
-```julia
+```@example indexred
 using OrdinaryDiffEq, LinearAlgebra
 function pendulum!(du, u, p, t)
     x, dx, y, dy, T = u
@@ -143,7 +143,7 @@ the numerical code into symbolic code, run `dae_index_lowering` lowering,
 then transform back to numerical code with `ODEProblem`, and solve with a
 numerical solver. Let's try that out:
 
-```julia
+```@example indexred
 traced_sys = modelingtoolkitize(pendulum_prob)
 pendulum_sys = structural_simplify(dae_index_lowering(traced_sys))
 prob = ODEProblem(pendulum_sys, Pair[], tspan)
@@ -153,8 +153,6 @@ using Plots
 plot(sol, vars=states(traced_sys))
 ```
 
-![](https://user-images.githubusercontent.com/1814174/110587364-9524b400-8141-11eb-91c7-4e56ce4fa20b.png)
-
 Note that plotting using `states(traced_sys)` is done so that any
 variables which are symbolically eliminated, or any variable reorderings
 done for enhanced parallelism/performance, still show up in the resulting
@@ -166,16 +164,14 @@ constructor, we can remove the algebraic equations from the states of the
 system and fully transform the index-3 DAE into an index-0 ODE which can
 be solved via an explicit Runge-Kutta method:
 
-```julia
+```@example indexred
 traced_sys = modelingtoolkitize(pendulum_prob)
 pendulum_sys = structural_simplify(dae_index_lowering(traced_sys))
 prob = ODAEProblem(pendulum_sys, Pair[], tspan)
 sol = solve(prob, Tsit5(),abstol=1e-8,reltol=1e-8)
 plot(sol, vars=states(traced_sys))
 ```
 
-![](https://user-images.githubusercontent.com/1814174/110587362-9524b400-8141-11eb-8b77-d940f108ae72.png)
-
 And there you go: this has transformed the model from being too hard to
 solve with implicit DAE solvers, to something that is easily solved with
 explicit Runge-Kutta methods for non-stiff equations.

docs/src/mtkitize_tutorials/sparse_jacobians.md

@@ -10,7 +10,7 @@ process.
 First let's start out with an implementation of the 2-dimensional Brusselator
 partial differential equation discretized using finite differences:
 
-```julia
+```@example sparsejac
 using DifferentialEquations, ModelingToolkit
 
 const N = 32
@@ -49,14 +49,14 @@ prob = ODEProblem(brusselator_2d_loop,u0,(0.,11.5),p)
 
 Now let's use `modelingtoolkitize` to generate the symbolic version:
 
-```julia
+```@example sparsejac
 sys = modelingtoolkitize(prob_ode_brusselator_2d)
 ```
 
 Now we regenerate the problem using `jac=true` for the analytical Jacobian
 and `sparse=true` to make it sparse:
 
-```julia
+```@example sparsejac
 sparseprob = ODEProblem(sys,Pair[],(0.,11.5),jac=true,sparse=true)
 ```