Modernize documentation (#759)

* Modernize documentation

* Correct the equation in Boundary conditions section

* Correct the equation in Systems of equations section

* Put spaces in code more consistently

* Do not put space around ..

* Fix example in Nonlinear equations

* Fix error in multivariate example code

Author: wsshin

docs/src/faq.md

@@ -1,3 +1,7 @@
+```@setup using-pkgs
+using ApproxFun, Random
+```
+
 # Frequently Asked Questions
 
 ## Approximating functions
@@ -6,108 +10,59 @@
 
 In the case where the grid is specified by `points(space,n)`, you can apply the default transform to data:
 
-```@meta
-DocTestSetup = quote
-    using ApproxFun
-end
-```
-
-```jldoctest
-julia> S = Chebyshev(1..2);
-
-julia> p = points(S,20); # the default grid
-
-julia> v = exp.(p);      # values at the default grid
-
-julia> f = Fun(S,ApproxFun.transform(S,v));
-
-julia> f(1.1)
-3.0041660239464347
-
-julia> exp(1.1)
-3.0041660239464334
+```@repl using-pkgs
+S = Chebyshev(1..2);
+p = points(S,20);  # the default grid
+v = exp.(p);  # values at the default grid
+f = Fun(S,ApproxFun.transform(S,v));
+f(1.1)
+exp(1.1)
 ```
 
 ApproxFun has no inbuilt support for interpolating functions at other sets of points, but this can be accomplished manually by evaluating the basis at the set of points and using \:
 
-```jldoctest
-julia> S = Chebyshev(1..2);
-
-julia> n = 50;
-
-julia> p = range(1,stop=2,length=n);   # a non-default grid
-
-julia> v = exp.(p);           # values at the non-default grid
-
-julia> V = Array{Float64}(undef,n,n); # Create a Vandermonde matrix by evaluating the basis at the grid
-
-julia> for k = 1:n
-           V[:,k] = Fun(S,[zeros(k-1);1]).(p)
-       end
-
-julia> f = Fun(S,V\v);
-
-julia> f(1.1)
-3.0041660228311926
-
-julia> exp(1.1)
-3.0041660239464334
+```@repl using-pkgs
+S = Chebyshev(1..2);
+n = 50;
+p = range(1,stop=2,length=n);  # a non-default grid
+v = exp.(p);  # values at the non-default grid
+V = Array{Float64}(undef,n,n);  # Create a Vandermonde matrix by evaluating the basis at the grid
+for k = 1:n
+   V[:,k] = Fun(S,[zeros(k-1);1]).(p)
+end
+f = Fun(S,V\v);
+f(1.1)
+exp(1.1)
 ```
 
 Note that an evenly spaced grid suffers from instability for large `n`.  The easiest way around this is to use least squares with more points than coefficients, instead of interpolation:
 
-```jldoctest
-julia> S = Chebyshev(1..2);
-
-julia> n = 100; m = 50;
-
-julia> p = range(1,stop=2,length=n);   # a non-default grid
-
-julia> v = exp.(p);           # values at the non-default grid
-
-julia> V = Array{Float64}(undef,n,m); # Create a Vandermonde matrix by evaluating the basis at the grid
-
-julia> for k = 1:m
-           V[:,k] = Fun(S,[zeros(k-1);1]).(p)
-       end
-
-julia> f = Fun(S,V\v);
-
-julia> f(1.1)
-3.004166023946434
-
-julia> exp(1.1)
-3.0041660239464334
+```@repl using-pkgs
+S = Chebyshev(1..2);
+n = 100; m = 50;
+p = range(1,stop=2,length=n);  # a non-default grid
+v = exp.(p);  # values at the non-default grid
+V = Array{Float64}(undef,n,m);  # Create a Vandermonde matrix by evaluating the basis at the grid
+for k = 1:m
+   V[:,k] = Fun(S,[zeros(k-1);1]).(p)
+end
+f = Fun(S,V\v);
+f(1.1)
+exp(1.1)
 ```
 
 We can use this same approach for multivariate functions:
 
-```jldoctest
-julia> S = Chebyshev(0..1)^2;
-
-julia> n = 1000; m = 50;
-
-julia> Random.seed!(0); x = rand(n); y = rand(n);
-
-julia> v = exp.(x .* cos(y));  # values at the non-default grid
-
-julia> V = Array{Float64}(undef,n,m); # Create a Vandermonde matrix by evaluating the basis at the grid
-
-julia> for k = 1:m
-          V[:,k] = Fun(S,[zeros(k-1);1]).(x,y)
-       end
-
-
-julia> f = Fun(S,V\v);
-
-julia> f(0.1,0.2)
-1.1029700685084018
-
-julia> exp(0.1*cos(0.2))
-1.1029701284210731
-```
-
-
-```@meta
-DocTestSetup = nothing
+```@repl using-pkgs
+S = Chebyshev(0..1)^2;
+n = 1000; m = 50;
+Random.seed!(0); x = rand(n); y = rand(n);
+v = exp.(x .* cos.(y));  # values at the non-default grid
+V = Array{Float64}(undef,n,m);  # Create a Vandermonde matrix by evaluating the basis at the grid
+for k = 1:m
+   V[:,k] = Fun(S,[zeros(k-1);1]).(x,y)
+end
+f = Fun(S,V\v);
+f(0.1,0.2)
+exp(0.1*cos(0.2))
 ```

docs/src/index.md

@@ -1,84 +1,75 @@
-# ApproxFun.jl Documentation
-
+```@setup using-pkgs
+using ApproxFun
+```
 
+# ApproxFun.jl Documentation
 
-ApproxFun is a package for approximating and manipulating functions,
-and for solving differential and integral equations.  
+ApproxFun is a package for approximating and manipulating functions, and for solving differential and integral equations.  
 
 ## Introduction
 
-A basic approach of computational mathematics that ApproxFun exploits is expansion
-in a basis
+A basic approach of computational mathematics that ApproxFun exploits is expansion in a basis
 
-$$f(x) \approx \sum_{k=1}^n c_k \psi_k(x)$$
+```math
+\mathop{f}(x) \approx \sum_{k=1}^n c_k \mathop{ψ}_k(x).
+```
 
-Some traditional examples of bases $\psi_1(x),\psi_2(x),\ldots$ are
-1. Taylor series: $1,z,z^2,\ldots$
-2. Fourier series (for periodic functions on `0..2π`): $1,\sin x, \cos x, \sin 2 x, \ldots$
-3. Chebyshev series (for non-periodic functions on `-1..1`): $1,x,\cos 2 \hbox{acos}\, x, \cos 3 \hbox{acos}\, x, \ldots$
+Some traditional examples of bases ``\mathop{ψ}_1(x), \mathop{ψ}_2(x), …`` are
 
-In ApproxFun, functions are represented by a `Fun` with two components: `space`,
-which dictates the basis and `coefficients` which is a finite vector of coefficients.  Note that each `Fun` can have a different length vector of
-coefficients, allowing for approximation of many different functions to high
-accuracy.  
+1. Taylor series: ``1, x, x^2, …``
+2. Fourier series (for periodic functions on `0..2π`): ``1, \sin{x}, \cos{x}, \sin{2x}, …``
+3. Chebyshev series (for non-periodic functions on `-1..1`): ``1, x, \cos(2\arccos{x}), \cos(3\arccos{x}), …``
+
+In ApproxFun, functions are represented by a `Fun` with two components: `space`, which dictates the basis and `coefficients` which is a finite vector of coefficients.  Note that each `Fun` can have a different length vector of coefficients, allowing for approximation of many different functions to high accuracy.  
 
 The approximation by a `Fun` can be determined by a variety of methods:
 
 (1) Explicitly specifying the coefficients:
-```julia
-julia> f = Fun(Taylor(),[1,2,3]) # Represents 1 + 2z + 3z^2
-Fun(Taylor(🕒),[1.0,2.0,3.0])
 
-julia> f(1.0)
-6.0
+```@repl using-pkgs
+f = Fun(Taylor(),[1,2,3])  # Represents 1 + 2x + 3x^2
+f(1.0)
 ```
-(2) Constructors take in a `Function` and adaptively determine the
-    number of coefficients.  For example,
-```julia
-julia> Fun(exp)
-Fun(Chebyshev(【-1.0,1.0】),[1.26607,1.13032,0.271495,0.0443368,0.00547424,0.000542926,4.49773e-5,3.19844e-6,1.99212e-7,1.10368e-8,5.5059e-10,2.49797e-11,1.03911e-12,3.99195e-14])
+
+(2) Constructors take in a `Function` and adaptively determine the number of coefficients.  For example,
+
+```@repl using-pkgs
+Fun(exp)
 ```
-determines that `f` can be approximated to roughly machine precision using
-14 coefficients.  See [Constructors](usage/constructors.md) for more information.
 
-(3) Manipulation of `Fun`s give new `Fun`s, where the number of coefficients is determined from the input.  The simplest example is addition, which for compatible bases is just padding the vectors to the same length and adding.  
-```julia
-julia> a = Fun(cos,Chebyshev()); ncoefficients(a)
-13
+determines that `f` can be approximated to roughly machine precision using 14 coefficients.  See [Constructors](usage/constructors.md) for more information.
 
-julia> b = Fun(x->cos(10cos(x^2)),Chebyshev()); ncoefficients(b)
-51
+(3) Manipulation of `Fun`s give new `Fun`s, where the number of coefficients is determined from the input.  The simplest example is addition, which for compatible bases is just padding the vectors to the same length and adding.  
 
-julia> ncoefficients(a+b)
-51
+```@repl using-pkgs
+a = Fun(cos,Chebyshev()); ncoefficients(a)
+b = Fun(x->cos(10cos(x^2)),Chebyshev()); ncoefficients(b)
+ncoefficients(a+b)
 ```
+
 On the other hand, multiplication results in an approximation with more coefficients than either `a` or `b`, so that the result approximates the true `a*b` to roughly machine accuracy:
-```
-julia> ncoefficients(a*b)
-63
 
-julia> a(0.1)*b(0.1) - (a*b)(0.1)
-1.1102230246251565e-16
+```@setup ab
+using ApproxFun
+a = Fun(cos,Chebyshev())
+b = Fun(x->cos(10cos(x^2)),Chebyshev())
 ```
 
+```@repl ab
+ncoefficients(a*b)
+a(0.1)*b(0.1) - (a*b)(0.1)
+```
 
-The example of multiplication highlights the importance of adaptivity: if with a fixed discretization size, operations like multiplication would lose accuracy when the true function is no longer resolved by the discretization.  More complicated examples are solving differential equations, where the
-coefficients of the solution can be determined adaptively, see [Equations](usage/equations.md).
-
-
-
-ApproxFun supports a number of different spaces, as described in [Spaces](usage/spaces.md).  A key component of ApproxFun is support for interaction between different
-spaces.  This is crucial for efficient solution of differential equations, where linear operators are described as acting between different spaces, see [Operators](usage/operators.md).  
+The example of multiplication highlights the importance of adaptivity: if with a fixed discretization size, operations like multiplication would lose accuracy when the true function is no longer resolved by the discretization.  More complicated examples are solving differential equations, where the coefficients of the solution can be determined adaptively, see [Equations](usage/equations.md).
 
+ApproxFun supports a number of different spaces, as described in [Spaces](usage/spaces.md).  A key component of ApproxFun is support for interaction between different spaces.  This is crucial for efficient solution of differential equations, where linear operators are described as acting between different spaces, see [Operators](usage/operators.md).  
 
 ## Contents
 
-
-
 ```@contents
-Pages = ["usage/constructors.md",
-         "usage/domains.md",
+Pages = ["usage/domains.md",
          "usage/spaces.md",
+         "usage/constructors.md",
          "usage/operators.md",
          "usage/equations.md",
          "faq.md",