Merge pull request #78 from ArnoStrouwen/docs1

Documenter 1.0 upgrade

Author: ChrisRackauckas

.github/workflows/CI.yml

@@ -3,9 +3,13 @@ on:
   pull_request:
     branches:
       - master
+    paths-ignore:
+      - 'docs/**'
   push:
     branches:
       - master
+    paths-ignore:
+      - 'docs/**'
 jobs:
   test:
     runs-on: ubuntu-latest

docs/Project.toml

@@ -3,5 +3,5 @@ MultiScaleArrays = "f9640e96-87f6-5992-9c3b-0743c6a49ffa"
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
 
 [compat]
-Documenter = "0.27"        
+Documenter = "1"        
 MultiScaleArrays = "1.10"

docs/make.jl

@@ -9,16 +9,8 @@ makedocs(sitename = "MultiScaleArrays.jl",
          authors = "Chris Rackauckas",
          modules = [MultiScaleArrays],
          clean = true, doctest = false, linkcheck = true,
-         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"],
+         warnonly = [:missing_docs],
+         format = Documenter.HTML(assets = ["assets/favicon.ico"],
                                   canonical = "https://docs.sciml.ai/MultiScaleArrays/stable/"),
          pages = pages)
 

docs/src/index.md

@@ -1,9 +1,9 @@
 # MultiScaleArrays.jl: High-Performance Matrix Exponentiation and Products
 
-MultiScaleArrays.jl allows you to easily build multiple scale models which are
+MultiScaleArrays.jl allows you to easily build multiple-scale models that are
 fully compatible with native Julia scientific computing packages like
 DifferentialEquations.jl or Optim.jl. These models utilize
-a tree structure to describe phenomena of multiple scales, but the interface allows
+a tree structure to describe phenomena on multiple scales, but the interface allows
 you to describe equations on different levels, using aggregations from lower
 levels to describe complex systems. Their structure allows for complex and dynamic
 models to be developed with only a small performance difference. In the end, they present
@@ -48,7 +48,7 @@ struct Embryo{T <: AbstractMultiScaleArray, B <: Number} <: AbstractMultiScaleAr
 end
 ```
 
-This setup defines a type structure which is both a tree and an array. A picture of a possible
+This setup defines a type structure that is both a tree and an array. A picture of a possible
 version is the following:
 
 ![](https://user-images.githubusercontent.com/1814174/27211626-79fe1b9a-520f-11e7-87f1-1cb33da91609.PNG)
@@ -61,7 +61,7 @@ cell2 = Cell([4.0; 5.0])
 ```
 
 and build types higher up in the hierarchy by using the `constuct` method. The method
-is `construct(T::AbstractMultiScaleArray, nodes, values)`, though, if `values` is not given it's
+is `construct(T::AbstractMultiScaleArray, nodes, values)`, though, if `values` is not given, it's
 taken to be empty.
 
 ```julia
@@ -150,32 +150,19 @@ Pkg.status(; mode = PKGMODE_MANIFEST) # hide
 </details>
 ```
 
-```@raw html
-You can also download the 
-<a href="
-```
-
-```@eval
-using TOML
-version = TOML.parse(read("../../Project.toml", String))["version"]
-name = TOML.parse(read("../../Project.toml", String))["name"]
-link = "https://github.com/SciML/" * name * ".jl/tree/gh-pages/v" * version *
-       "/assets/Manifest.toml"
-```
-
-```@raw html
-">manifest</a> file and the
-<a href="
-```
-
 ```@eval
 using TOML
+using Markdown
 version = TOML.parse(read("../../Project.toml", String))["version"]
 name = TOML.parse(read("../../Project.toml", String))["name"]
-link = "https://github.com/SciML/" * name * ".jl/tree/gh-pages/v" * version *
-       "/assets/Project.toml"
-```
-
-```@raw html
-">project</a> file.
-```
+link_manifest = "https://github.com/SciML/" * name * ".jl/tree/gh-pages/v" * version *
+                "/assets/Manifest.toml"
+link_project = "https://github.com/SciML/" * name * ".jl/tree/gh-pages/v" * version *
+               "/assets/Project.toml"
+Markdown.parse("""You can also download the
+[manifest]($link_manifest)
+file and the
+[project]($link_project)
+file.
+""")
+```

src/MultiScaleArrays.jl

@@ -24,24 +24,24 @@ Each type above then contains three fields:
 
 Note that the ordering of the fields matters.
 `B` is the `BottomType`, which has to be the same as the eltype for the array
-in the leaf types. `T` is another `AbstractMultiScaleArray`. Thus at each level,
-an` AbstractMultiScaleArray` contains some information of its own (`values`), the
+in the leaf types. `T` is another `AbstractMultiScaleArray`. Thus, at each level,
+an `AbstractMultiScaleArray` contains some information of its own (`values`), the
 next level down in the hierarchy (`nodes`), and caching for indices (`end_idxs`).
-You can add and use extra fields as you please, and even make the types immutable.
+You can add and use extra fields as you please, and you can even make the types immutable.
 
 ## The MultiScaleModel API
 
 The resulting type acts as an array. A leaf type `l` acts exactly as an array
 with `l[i] == l.values[i]`. Higher nodes also act as a linear array. If `ln` is level
 `n` in the hierarchy, then `ln.nodes` is the vector of level `n-1` objects, and `ln.values`
-are its "intrinsic values". There is an indexing scheme on `ln`, where:
+are its “intrinsic values”. There is an indexing scheme on `ln`, where:
 
   - `ln[i,j,k]` gets the `k`th `n-3` object in the `j`th `n-2` object in the `i`th level `n-1`
     object. Of course, this recurses for the whole hierarchy.
   - `ln[i]` provides a linear index through all `.nodes` and `.values` values in every lower
     level and `ln.values` itself.
 
-Thus `typeof(ln) <: AbstractVector{B}` where `B` is the eltype of its leaves and
+Thus, `typeof(ln) <: AbstractVector{B}`, where `B` is the eltype of its leaves and
 all `.values`'s.
 
 In addition, iterators are provided to make it easy to iterate through levels.
@@ -59,7 +59,7 @@ mimics a vector in order for usage in DifferentialEquations or Optim. So for exa
 embryo[12]
 ```
 
-returns the "12th protein", counting by Embryo > Tissue > Population > Cell in order
+returns the “12th protein”, counting by Embryo > Tissue > Population > Cell in order
 of the vectors. The linear indexing exists for every `AbstractMultiScaleArray`.
 These types act as full linear vectors, so standard operations do the sensical
 operations:
@@ -82,7 +82,7 @@ for cell in level_iter(embryo, 3)
 end
 ```
 
-or the multiple level iter, which is the one generally used in
+or the multiple-level iter, which is the one generally used in
 DifferentialEquations.jl functions:
 
 ```julia
@@ -101,7 +101,7 @@ end
 ```
 
 However, the interesting behavior comes from event handling. Since `embryo` will be the
-"vector" for the differential equation or optimization problem, it will be the value
+“vector” for the differential equation or optimization problem, it will be the value
 passed to the event handling. MultiScaleArrays includes behavior for changing the
 structure. For example: