Merge pull request #185 from ArnoStrouwen/patch-4

example blocks

Author: ChrisRackauckas

docs/src/advanced/custom.md

@@ -7,7 +7,7 @@ interface to be easily extendable by users. To that end, the linear solve algori
 user can pass in their custom linear solve function, say `my_linsolve`, to
 `LinearSolveFunction()`. A contrived example of solving a linear system with a custom solver is below.
 
-```julia
+```@example advanced1
 using LinearSolve, LinearAlgebra
 
 function my_linsolve(A,b,u,p,newA,Pl,Pr,solverdata;verbose=true, kwargs...)
@@ -21,6 +21,7 @@ end
 prob = LinearProblem(Diagonal(rand(4)), rand(4))
 alg  = LinearSolveFunction(my_linsolve)
 sol  = solve(prob, alg)
+sol.u
 ```
 The inputs to the function are as follows:
 - `A`, the linear operator
@@ -36,7 +37,7 @@ The inputs to the function are as follows:
 The function `my_linsolve` must accept the above specified arguments, and return
 the solution, `u`. As memory for `u` is already allocated, the user may choose
 to modify `u` in place as follows:
-```julia
+```@example advanced1
 function my_linsolve!(A,b,u,p,newA,Pl,Pr,solverdata;verbose=true, kwargs...)
     if verbose == true
         println("solving Ax=b")
@@ -47,4 +48,5 @@ end
 
 alg  = LinearSolveFunction(my_linsolve!)
 sol  = solve(prob, alg)
+sol.u
 ```

docs/src/basics/FAQ.md

@@ -39,30 +39,40 @@ IterativeSolvers.jl computes the norm after the application of the left precondt
 `Pl`. Thus in order to use a vector tolerance `weights`, one can mathematically
 hack the system via the following formulation:
 
-```julia
+```@example FAQPrec
 using LinearSolve, LinearAlgebra
-Pl = LinearSolve.InvPreconditioner(Diagonal(weights))
-Pr = Diagonal(weights)
 
+n = 2
 A = rand(n,n)
 b = rand(n)
 
+weights = [1e-1, 1]
+Pl = LinearSolve.InvPreconditioner(Diagonal(weights))
+Pr = Diagonal(weights)
+
+
 prob = LinearProblem(A,b)
 sol = solve(prob,IterativeSolversJL_GMRES(),Pl=Pl,Pr=Pr)
+
+sol.u
 ```
 
 If you want to use a "real" preconditioner under the norm `weights`, then one
 can use `ComposePreconditioner` to apply the preconditioner after the application
 of the weights like as follows:
 
-```julia
+```@example FAQ2
 using LinearSolve, LinearAlgebra
-Pl = ComposePreconitioner(LinearSolve.InvPreconditioner(Diagonal(weights),realprec))
-Pr = Diagonal(weights)
 
+n = 4
 A = rand(n,n)
 b = rand(n)
 
+weights = rand(n)
+realprec = lu(rand(n,n)) # some random preconditioner
+Pl = LinearSolve.ComposePreconditioner(LinearSolve.InvPreconditioner(Diagonal(weights)),realprec)
+Pr = Diagonal(weights)
+
 prob = LinearProblem(A,b)
 sol = solve(prob,IterativeSolversJL_GMRES(),Pl=Pl,Pr=Pr)
 ```

docs/src/basics/Preconditioners.md

@@ -41,8 +41,9 @@ preconditioned system which first divides by some random numbers and then
 multiplies by the same values. This is commonly used in the case where if, instead
 of random, `s` is an approximation to the eigenvalues of a system.
 
-```julia
+```@example precon
 using LinearSolve, LinearAlgebra
+n = 4
 s = rand(n)
 Pl = Diagonal(s)
 
@@ -51,6 +52,7 @@ b = rand(n)
 
 prob = LinearProblem(A,b)
 sol = solve(prob,IterativeSolversJL_GMRES(),Pl=Pl)
+sol.u
 ```
 
 ## Preconditioner Interface

docs/src/tutorials/caching_interface.md

@@ -20,7 +20,7 @@ LinearSolve.jl's caching interface automates this process to use the most effici
 means of solving and resolving linear systems. To do this with LinearSolve.jl,
 you simply `init` a cache, `solve`, replace `b`, and solve again. This looks like:
 
-```julia
+```@example linsys2
 using LinearSolve
 
 n = 4
@@ -32,42 +32,22 @@ linsolve = init(prob)
 sol1 = solve(linsolve)
 
 sol1.u
-#=
-4-element Vector{Float64}:
- -0.9247817429364165
- -0.0972021708185121
-  0.6839050402960025
-  1.8385599677530706
-=#
-
+```
+```@example linsys2
 linsolve = LinearSolve.set_b(sol1.cache,b2)
 sol2 = solve(linsolve)
 
 sol2.u
-#=
-4-element Vector{Float64}:
-  1.0321556637762768
-  0.49724400693338083
- -1.1696540870182406
- -0.4998342686003478
-=#
 ```
 
 Then refactorization will occur when a new `A` is given:
 
-```julia
+```@example linsys2
 A2 = rand(n,n)
 linsolve = LinearSolve.set_A(sol2.cache,A2)
 sol3 = solve(linsolve)
 
 sol3.u
-#=
-4-element Vector{Float64}:
- -6.793605395935224
-  2.8673042300837466
-  1.1665136934977371
- -0.4097250749016653
-=#
 ```
 
 The factorization occurs on the first solve, and it stores the factorization in

docs/src/tutorials/linear.md

@@ -8,22 +8,14 @@ of simplicity, this tutorial will only showcase concrete matrices.
 The following defines a matrix and a `LinearProblem` which is subsequently solved
 by the default linear solver.
 
-```julia
+```@example linsys1
 using LinearSolve
 
 A = rand(4,4)
 b = rand(4)
 prob = LinearProblem(A, b)
 sol = solve(prob)
 sol.u
-
-#=
-4-element Vector{Float64}:
-  0.3784870087078603
-  0.07275749718047864
-  0.6612816064734302
- -0.10598367531463938
-=#
 ```
 
 Note that `solve(prob)` is equivalent to `solve(prob,nothing)` where `nothing`
@@ -35,16 +27,9 @@ has some nice methods like GMRES which can be faster in some cases. With
 LinearSolve.jl, there is one interface and changing linear solvers is simply
 the switch of the algorithm choice:
 
-```julia
+```@example linsys1
 sol = solve(prob,IterativeSolversJL_GMRES())
-
-#=
-u: 4-element Vector{Float64}:
-  0.37848700870786
-  0.07275749718047908
-  0.6612816064734302
- -0.10598367531463923
-=#
+sol.u
 ```
 
 Thus a package which uses LinearSolve.jl simply needs to allow the user to