Change repl to jldoctest in docs (#840)

* Change repl to jldoctest in docs

* floating point fixes + filter

* filter in constructor

* split abs space doctests

Author: jishnub

docs/src/usage/constructors.md

@@ -8,21 +8,51 @@ end
 
 `Fun`s in ApproxFun are instances of Julia types with one field to store coefficients and another to describe the function space. Similarly, each function space has one field describing its domain, or another function space. Let's explore:
 
-```@repl
-x = Fun(identity,-1..1);
-f = exp(x);
-g = f/sqrt(1-x^2);
-space(f)  # Output is pretty version of Chebyshev(Interval(-1.0,1.0))
-space(g)  # Output is pretty version of JacobiWeight(-0.5,-0.5,Interval(-1.0,1.0))
+```jldoctest
+julia> x = Fun(identity,-1..1);
+
+julia> f = exp(x);
+
+julia> g = f/sqrt(1-x^2);
+
+julia> space(f)  # Output is pretty version of Chebyshev(Interval(-1.0,1.0))
+Chebyshev(-1..1)
+
+julia> space(g)  # Output is pretty version of JacobiWeight(-0.5, -0.5, -1..1)
+(1-x^2)^-0.5[Chebyshev(-1..1)]
 ```
 
 The absolute value is another case where the space of the output is inferred from the operation:
 
-```@repl
-f = Fun(x->cospi(5x),-1..1);
-g = abs(f);
-space(f)
-space(g)
+```@meta
+DocTestFilters = r"ContinuousSpace{Float64, Float64}\(PiecewiseSegment{Float64}\(\[[0-9,\.\s\-]+\]\)\)"
+```
+```jldoctest abs_space
+julia> f = Fun(x->cospi(5x),-1..1);
+
+julia> g = abs(f);
+
+julia> space(f)
+Chebyshev(-1..1)
+
+julia> space(g)
+ContinuousSpace{Float64, Float64}(PiecewiseSegment{Float64}([-1.0, -0.9, -0.7000000000000014, -0.5000000000000008, -0.2999999999999996, -0.10000000000000027, 0.09999999999999978, 0.29999999999999993, 0.4999999999999999, 0.6999999999999998, 0.9, 1.0]))
+```
+```@meta
+DocTestFilters = nothing
+```
+We may check that the domain corresponds to segments separated by the roots of `f`, and the space is
+that of continuous functions over the piecewise domain:
+```jldoctest abs_space
+julia> p = [-1; roots(f); 1];
+
+julia> segments = @views [Segment(x,y) for (x,y) in zip(p[1:end-1], p[2:end])];
+
+julia> components(domain(g)) == segments
+true
+
+julia> space(g) == ContinuousSpace(PiecewiseSegment(reverse(segments)))
+true
 ```
 
 ## Convenience constructors
@@ -53,10 +83,11 @@ x = Fun()
 
 It is sometimes necessary to specify coefficients explicitly.  This is possible via specifying the space followed by a vector of coefficients:
 
-```@repl
-f = Fun(Taylor(), [1,2,3]);  # represents 1 + 2z + 3z^2
-f(0.1)
-1 + 2*0.1 + 3*0.1^2
+```jldoctest
+julia> f = Fun(Taylor(), [1,2,3]);  # represents 1 + 2z + 3z^2
+
+julia> f(0.1) ≈ 1 + 2*0.1 + 3*0.1^2
+true
 ```
 
 In higher dimensions, ApproxFun will sum products of the 1D basis functions. So if ``\mathop{T}_i(x)`` is the ``i``th basis function, then a 2D function can be approximated as the following:
@@ -79,10 +110,11 @@ For example, if we are in the two dimensional CosSpace space and we have coeffic
 
 This is illustrated in the following code:
 
-```@repl
-f = Fun(CosSpace()^2, [1,2,3])
-f(1,2)
-1cos(0*1)*cos(0*2) + 2cos(0*1)*cos(1*2) + 3cos(1*1)*cos(0*2)
+```jldoctest
+julia> f = Fun(CosSpace()^2, [1,2,3]);
+
+julia> f(1,2) ≈ 1cos(0*1)*cos(0*2) + 2cos(0*1)*cos(1*2) + 3cos(1*1)*cos(0*2)
+true
 ```
 
 ## Using ApproxFun for “manual” interpolation

docs/src/usage/equations.md

@@ -14,11 +14,17 @@ Linear equations such as ordinary and partial differential equations, fractional
 
 where we want a solution that is periodic on ``[0,2π)``.  This can be solved succinctly as follows:
 
-```@repl
-b = Fun(cos,Fourier());
-c = 0.1; u = (𝒟+c*I) \ b;
-u(0.6)
-(c*cos(0.6)+sin(0.6)) / (1+c^2)  # exact solution
+```jldoctest
+julia> b = Fun(cos, Fourier());
+
+julia> c = 0.1;
+
+julia> u = (𝒟 + c*I) \ b;
+
+julia> t = 0.6; # choose a point to verify the solution
+
+julia> u(t) ≈ (c*cos(t)+sin(t)) / (1+c^2) # exact solution
+true
 ```
 
 Recall that `𝒟` is an alias to `Derivative() == Derivative(UnsetSpace(),1)`.
@@ -31,13 +37,25 @@ As another example, consider the Fredholm integral equation
 
 We can solve this equation as follows:
 
-```@repl
-Σ = DefiniteIntegral(Chebyshev()); x = Fun();
-u = (I+exp(x)*Σ[cos(x)]) \ cos(exp(x));
-u(0.1)
+```@meta
+DocTestFilters = r"[0-9\.]+"
+```
+```jldoctest fredholm
+julia> Σ = DefiniteIntegral(Chebyshev());
+
+julia> x = Fun();
+
+julia> u = (I+exp(x)*Σ[cos(x)]) \ cos(exp(x));
+
+julia> u(0.1)
+0.21864294855628819
+```
+```@meta
+DocTestFilters = nothing
 ```
 
-Note that we used the syntax `op[f::Fun]`, which is a shorthand for `op*Multiplication(f)`.
+!!! note
+    We used the syntax `op[f::Fun]`, which is a shorthand for `op * Multiplication(f)`.
 
 ## Boundary conditions
 
@@ -52,11 +70,16 @@ Incorporating boundary conditions into differential equations is important so th
 
 To pose this in ApproxFun, we want to find a `u` such that `Evaluation(0)*u == 1` and `(𝒟 - t)*u == 0`.  This is accomplished via:
 
-```@repl
-t = Fun(0..1);
-u = [Evaluation(0); 𝒟-t] \ [1;0];
-u(0)
-norm(u'-t*u)
+```jldoctest
+julia> t = Fun(0..1);
+
+julia> u = [Evaluation(0); 𝒟-t] \ [1;0];
+
+julia> u(0) ≈ 1
+true
+
+julia> norm(u'-t*u) < eps()
+true
 ```
 
 Behind the scenes, the `Vector{Operator{T}}` representing the functionals and operators are combined into a single `InterlaceOperator`.
@@ -72,23 +95,27 @@ A common usage is two-point boundary value problems. Consider the singularly per
 
 This can be solved in ApproxFun via:
 
-```@repl
-ϵ = 1/70; x = Fun();
-u = [Evaluation(-1);
-     Evaluation(1);
-     ϵ*𝒟^2-x*𝒟+I] \ [1,2,0];
-u(0.1)
+```jldoctest twopt
+julia> ϵ = 1/70;
+
+julia> x = Fun();
+
+julia> u = [Evaluation(-1); Evaluation(1); ϵ*𝒟^2-x*𝒟+I] \ [1,2,0];
+
+julia> u(0.1) ≈ 0.05 # compare with the analytical solution
+true
 ```
 
-Note in this case the space is inferred from the variable coefficient `x`.
+!!! note
+    In this case the space is inferred from the variable coefficient `x`.
+
+This ODE can also be solved using the [`Dirichlet`](@ref) operator:
 
-This ODE can also be solved using the `Dirichlet` operator:
+```jldoctest twopt
+julia> u = [Dirichlet(); ϵ*𝒟^2-x*𝒟+I] \ [[1,2],0];
 
-```@repl
-x = Fun();
-u = [Dirichlet();
-     1/70*𝒟^2-x*𝒟+I] \ [[1,2],0];
-u(0.1)
+julia> u(0.1) ≈ 0.05 # compare with the analytical solution
+true
 ```
 
 ## QR Factorization