diff --git a/.JuliaFormatter.toml b/.JuliaFormatter.toml
index 453925c..9c79359 100644
--- a/.JuliaFormatter.toml
+++ b/.JuliaFormatter.toml
@@ -1 +1,2 @@
-style = "sciml"
\ No newline at end of file
+style = "sciml"
+format_markdown = true
\ No newline at end of file
diff --git a/LICENSE.md b/LICENSE.md
index dec5eb5..a315925 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -1,40 +1,33 @@
The LabelledArrays.jl package is licensed under the MIT "Expat" License:
> Copyright (c) 2017: Christopher Rackauckas.
->
->
+>
> Permission is hereby granted, free of charge, to any person obtaining a copy
->
+>
> of this software and associated documentation files (the "Software"), to deal
->
+>
> in the Software without restriction, including without limitation the rights
->
+>
> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
->
+>
> copies of the Software, and to permit persons to whom the Software is
->
+>
> furnished to do so, subject to the following conditions:
->
->
->
+>
> The above copyright notice and this permission notice shall be included in all
->
+>
> copies or substantial portions of the Software.
->
->
->
+>
> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
->
+>
> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
->
+>
> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
->
+>
> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
->
+>
> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
->
+>
> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
->
+>
> SOFTWARE.
->
->
diff --git a/README.md b/README.md
index 320e875..13b3cc7 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@
[](https://codecov.io/gh/SciML/LabelledArrays.jl)
[](https://github.com/SciML/LabelledArrays.jl/actions?query=workflow%3ACI)
-[](https://github.com/SciML/ColPrac)
+[](https://github.com/SciML/ColPrac)
[](https://github.com/SciML/SciMLStyle)
# About
@@ -19,10 +19,12 @@ are labelled. Thus for instance you can set that the second component is named
## How to install
The package can be installed from this repository by
+
```julia
-> using Pkg
-> Pkg.add("LabelledArrays")
+using Pkg
+Pkg.add("LabelledArrays")
```
+
## Tutorials and Documentation
For information on using the package,
@@ -37,28 +39,28 @@ First you create the type and then you can use that constructor to generate
instances of the labelled array.
```julia
-ABC = @SLVector (:a,:b,:c)
-A = ABC(1,2,3)
+ABC = @SLVector (:a, :b, :c)
+A = ABC(1, 2, 3)
A.a == 1
-ABCD = @SLArray (2,2) (:a,:b,:c,:d)
-B = ABCD(1,2,3,4)
+ABCD = @SLArray (2, 2) (:a, :b, :c, :d)
+B = ABCD(1, 2, 3, 4)
B.c == 3
-B[2,2] == B.d
+B[2, 2] == B.d
```
Here we have that `A == [1,2,3]` and for example `A.b == 2`. We can create a
typed `SLArray` via:
```julia
-SVType = @SLVector Float64 (:a,:b,:c)
+SVType = @SLVector Float64 (:a, :b, :c)
```
Alternatively, you can also construct a static labelled array using the
`SLVector` constructor by writing out the entries as keyword arguments:
```julia
-julia> SLVector(a=1, b=2, c=3)
+julia> SLVector(a = 1, b = 2, c = 3)
3-element SLArray{Tuple{3},1,(:a, :b, :c),Int64}:
1
2
@@ -69,7 +71,7 @@ For general N-dimensional labelled arrays, you need to specify the size
(`Tuple{dim1,dim2,...}`) as the type parameter to the `SLArray` constructor:
```julia
-julia> SLArray{Tuple{2,2}}(a=1, b=2, c=3, d=4)
+julia> SLArray{Tuple{2, 2}}(a = 1, b = 2, c = 3, d = 4)
2×2 SLArray{Tuple{2,2},2,(:a, :b, :c, :d),Int64}:
1 3
2 4
@@ -80,8 +82,9 @@ a keyword constructor whose first argument is the source and
additonal keyword arguments change several entries.
```julia
-julia> v1 = SLVector(a=1.1, b=2.2, c=3.3);
-julia> v2 = SLVector(v1; b=20.20, c=30.30 )
+julia> v1 = SLVector(a = 1.1, b = 2.2, c = 3.3);
+
+julia> v2 = SLVector(v1; b = 20.20, c = 30.30)
3-element SLArray{Tuple{3},Float64,1,3,(:a, :b, :c)}:
1.1
20.2
@@ -89,18 +92,22 @@ julia> v2 = SLVector(v1; b=20.20, c=30.30 )
```
```julia
-julia> ABCD = @SLArray (2,2) (:a,:b,:c,:d);
-julia> B = ABCD(1,2,3,4);
-julia> B2 = SLArray(B; c=30 )
+julia> ABCD = @SLArray (2, 2) (:a, :b, :c, :d);
+
+julia> B = ABCD(1, 2, 3, 4);
+
+julia> B2 = SLArray(B; c = 30)
2×2 SLArray{Tuple{2,2},Int64,2,4,(:a, :b, :c, :d)}:
1 30
2 4
```
One can also specify the indices directly.
+
```julia
-julia> EFG = @SLArray (2,2) (e=1:3, f=4, g=2:4);
-julia> y = EFG(1.0,2.5,3.0,5.0)
+julia> EFG = @SLArray (2, 2) (e = 1:3, f = 4, g = 2:4);
+
+julia> y = EFG(1.0, 2.5, 3.0, 5.0)
2×2 SLArray{Tuple{2,2},Float64,2,4,(e = 1:3, f = 4, g = 2:4)}:
1.0 3.0
2.5 5.0
@@ -112,7 +119,9 @@ julia> y.g
5.0
julia> Arr = @SLArray (2, 2) (a = (2, :), b = 3);
+
julia> z = Arr(1, 2, 3, 4);
+
julia> z.a
2-element view(::StaticArrays.SArray{Tuple{2,2},Int64,2,4}, 2, :) with eltype Int64:
2
@@ -126,7 +135,7 @@ loss by using the labelled instead of indexing. Using the macro with values
and labels generates the labelled array with the given values:
```julia
-A = @LArray [1,2,3] (:a,:b,:c)
+A = @LArray [1, 2, 3] (:a, :b, :c)
A.a == 1
```
@@ -134,16 +143,16 @@ One can generate a labelled array with undefined values by instead giving
the dimensions:
```julia
-A = @LArray Float64 (2,2) (:a,:b,:c,:d)
-W = rand(2,2)
+A = @LArray Float64 (2, 2) (:a, :b, :c, :d)
+W = rand(2, 2)
A .= W
-A.d == W[2,2]
+A.d == W[2, 2]
```
or using an `@LVector` shorthand:
```julia
-A = @LVector Float64 (:a,:b,:c,:d)
+A = @LVector Float64 (:a, :b, :c, :d)
A .= rand(4)
```
@@ -151,38 +160,39 @@ As with `SLArray`, alternative constructors exist that use the keyword argument
form:
```julia
-julia> LVector(a=1, b=2, c=3)
+julia> LVector(a = 1, b = 2, c = 3)
3-element LArray{Int64,1,(:a, :b, :c)}:
1
2
3
-julia> LArray((2,2); a=1, b=2, c=3, d=4) # need to specify size as first argument
+julia> LArray((2, 2); a = 1, b = 2, c = 3, d = 4) # need to specify size as first argument
2×2 LArray{Int64,2,(:a, :b, :c, :d)}:
1 3
2 4
```
One can also specify the indices directly.
+
```julia
-julia> z = @LArray [1.,2.,3.] (a = 1:2, b = 2:3);
+julia> z = @LArray [1.0, 2.0, 3.0] (a = 1:2, b = 2:3);
+
julia> z.b
2-element view(::Array{Float64,1}, 2:3) with eltype Float64:
2.0
3.0
+
julia> z = @LArray [1 2; 3 4] (a = (2, :), b = 2:3);
+
julia> z.a
2-element view(::Array{Int64,2}, 2, :) with eltype Int64:
3
4
```
-The labels of LArray and SLArray can be accessed
+The labels of LArray and SLArray can be accessed
by function `symbols`, which returns a tuple of symbols.
-
-
-
## Example: Nice DiffEq Syntax Without A DSL
LabelledArrays.jl are a way to get DSL-like syntax without a macro. In this case,
@@ -194,17 +204,17 @@ Let's solve the Lorenz equation. Using `@LVector`s, we can do:
```julia
using LabelledArrays, OrdinaryDiffEq
-function lorenz_f(du,u,p,t)
- du.x = p.σ*(u.y-u.x)
- du.y = u.x*(p.ρ-u.z) - u.y
- du.z = u.x*u.y - p.β*u.z
+function lorenz_f(du, u, p, t)
+ du.x = p.σ * (u.y - u.x)
+ du.y = u.x * (p.ρ - u.z) - u.y
+ du.z = u.x * u.y - p.β * u.z
end
-u0 = @LArray [1.0,0.0,0.0] (:x,:y,:z)
-p = @LArray [10.0, 28.0, 8/3] (:σ,:ρ,:β)
-tspan = (0.0,10.0)
-prob = ODEProblem(lorenz_f,u0,tspan,p)
-sol = solve(prob,Tsit5())
+u0 = @LArray [1.0, 0.0, 0.0] (:x, :y, :z)
+p = @LArray [10.0, 28.0, 8 / 3] (:σ, :ρ, :β)
+tspan = (0.0, 10.0)
+prob = ODEProblem(lorenz_f, u0, tspan, p)
+sol = solve(prob, Tsit5())
# Now the solution can be indexed as .x/y/z as well!
sol[10].x
```
@@ -212,21 +222,21 @@ sol[10].x
We can also make use of `@SLVector`:
```julia
-LorenzVector = @SLVector (:x,:y,:z)
-LorenzParameterVector = @SLVector (:σ,:ρ,:β)
-
-function f(u,p,t)
- x = p.σ*(u.y-u.x)
- y = u.x*(p.ρ-u.z) - u.y
- z = u.x*u.y - p.β*u.z
- LorenzVector(x,y,z)
+LorenzVector = @SLVector (:x, :y, :z)
+LorenzParameterVector = @SLVector (:σ, :ρ, :β)
+
+function f(u, p, t)
+ x = p.σ * (u.y - u.x)
+ y = u.x * (p.ρ - u.z) - u.y
+ z = u.x * u.y - p.β * u.z
+ LorenzVector(x, y, z)
end
-u0 = LorenzVector(1.0,0.0,0.0)
-p = LorenzParameterVector(10.0,28.0,8/3)
-tspan = (0.0,10.0)
-prob = ODEProblem(f,u0,tspan,p)
-sol = solve(prob,Tsit5())
+u0 = LorenzVector(1.0, 0.0, 0.0)
+p = LorenzParameterVector(10.0, 28.0, 8 / 3)
+tspan = (0.0, 10.0)
+prob = ODEProblem(f, u0, tspan, p)
+sol = solve(prob, Tsit5())
```
## Relation to NamedTuples
@@ -234,29 +244,29 @@ sol = solve(prob,Tsit5())
Julia's Base has NamedTuples in v0.7+. They are constructed as:
```julia
-p = (σ = 10.0,ρ = 28.0,β = 8/3)
+p = (σ = 10.0, ρ = 28.0, β = 8 / 3)
```
and they support `p[1]` and `p.σ` as well. The `LVector`, `SLVector`, `LArray`
and `SLArray` constructors also support named tuples as their arguments:
```julia
-julia> LVector((a=1, b=2))
+julia> LVector((a = 1, b = 2))
2-element LArray{Int64,1,(:a, :b)}:
1
2
-julia> SLVector((a=1, b=2))
+julia> SLVector((a = 1, b = 2))
2-element SLArray{Tuple{2},1,(:a, :b),Int64}:
1
2
-julia> LArray((2,2), (a=1, b=2, c=3, d=4))
+julia> LArray((2, 2), (a = 1, b = 2, c = 3, d = 4))
2×2 LArray{Int64,2,(:a, :b, :c, :d)}:
1 3
2 4
-julia> SLArray{Tuple{2,2}}((a=1, b=2, c=3, d=4))
+julia> SLArray{Tuple{2, 2}}((a = 1, b = 2, c = 3, d = 4))
2×2 SLArray{Tuple{2,2},2,(:a, :b, :c, :d),Int64}:
1 3
2 4
@@ -269,18 +279,17 @@ creates an iterator that is functionally the same as
for each label of the array.
There are some crucial differences between a labelled array and
-a named tuple. Labelled arrays can have any dimensions while
+a named tuple. Labelled arrays can have any dimensions while
named tuples are always 1D. A named tuple can have different types
on each element, while an `SLArray` can only have one element
type and furthermore it has the actions of a static vector.
-As a result `SLArray` has less element type information, which
+As a result `SLArray` has less element type information, which
improves compilation speed while giving more vector functionality
than a NamedTuple. `LArray` also only has a single element type and,
unlike a named tuple, is mutable.
-
## Note: Labelled slices
-This functionality has been removed from LabelledArrays.jl, but can
-replicated with the same compile-time performance and indexing syntax
+This functionality has been removed from LabelledArrays.jl, but can
+replicated with the same compile-time performance and indexing syntax
using [DimensionalData.jl](https://rafaqz.github.io/DimensionalData.jl/stable/).
diff --git a/docs/make.jl b/docs/make.jl
index 9d787b9..2ef2a9f 100644
--- a/docs/make.jl
+++ b/docs/make.jl
@@ -8,7 +8,15 @@ include("pages.jl")
makedocs(sitename = "LabelledArrays.jl",
authors = "Chris Rackauckas",
modules = [LabelledArrays],
- clean = true, doctest = false,
+ 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"],
canonical = "https://docs.sciml.ai/LabelledArrays/stable/"),
diff --git a/docs/src/Example_dsl.md b/docs/src/Example_dsl.md
index e184196..780e4a8 100644
--- a/docs/src/Example_dsl.md
+++ b/docs/src/Example_dsl.md
@@ -1,72 +1,71 @@
# Example: Nice DiffEq Syntax Without A DSL
Users of the SciML ecosystem are often solving large models with complicated
-states and/or hundreds or thousands of parameters. These models are implemented
-using arrays, and those arrays have traditionally been indexed by integers,
-such as `p[1]` or `p[1:5]`. Numerical indexing is wonderful for small
-models, but can quickly cause problems as models become bigger. It is easy to
-forget which index corresponds to which reaction rate or which diffusion coeffient.
-This confusion can lead to difficult to debug problems in a user's code. `LabelledArrays`
-can make an important difference here. It is much easier to build a model using parameter
-references such as `p.rate_nacl` or `p.probability_birth`, instead
-of `p[26]` or `p[1026]`. Labelled arrays make both the development and debugging of models
-much faster.
+states and hundreds or thousands of parameters. These models are implemented
+using arrays, and those arrays have traditionally been indexed by integers,
+such as `p[1]` or `p[1:5]`. Numerical indexing is wonderful for small
+models, but can quickly cause problems as models become bigger. It is easy to
+forget which index corresponds to which reaction rate or which diffusion coefficient.
+This confusion can lead to difficult to debug problems in a user's code. `LabelledArrays`
+can make an important difference here. It is much easier to build a model using parameter
+references such as `p.rate_nacl` or `p.probability_birth`, instead
+of `p[26]` or `p[1026]`. Labelled arrays make both the development and debugging of models
+much faster.
LabelledArrays.jl are a way to get DSL-like syntax without a macro. In this case,
we can solve differential equations with labelled components by making use of
labelled arrays, and always refer to the components by name instead of index.
-One key caveat is that users do not need to sacrifice performance when using
-labelled arrays. Labelled arrays are as performant as traditional numerically
+One key caveat is that users do not need to sacrifice performance when using
+labelled arrays. Labelled arrays are as performant as traditional numerically
indexed arrays.
-Let's solve the Lorenz equation using an `LVector`s. `LVectors` are
-mutable, hence we can use the non-allocating form of the `OrdinaryDiffEq`
+Let's solve the Lorenz equation using an `LVector`s. `LVectors` are
+mutable. Hence, we can use the non-allocating form of the `OrdinaryDiffEq`
API.
```julia
using LabelledArrays, OrdinaryDiffEq
-function lorenz_f!(du,u,p,t)
- du.x = p.σ*(u.y-u.x)
- du.y = u.x*(p.ρ-u.z) - u.y
- du.z = u.x*u.y - p.β*u.z
+function lorenz_f!(du, u, p, t)
+ du.x = p.σ * (u.y - u.x)
+ du.y = u.x * (p.ρ - u.z) - u.y
+ du.z = u.x * u.y - p.β * u.z
end
-u0 = @LArray [1.0,0.0,0.0] (:x,:y,:z)
-p = @LArray [10.0, 28.0, 8/3] (:σ,:ρ,:β)
-tspan = (0.0,10.0)
-prob = ODEProblem(lorenz_f!,u0,tspan,p)
-sol = solve(prob,Tsit5())
+u0 = @LArray [1.0, 0.0, 0.0] (:x, :y, :z)
+p = @LArray [10.0, 28.0, 8 / 3] (:σ, :ρ, :β)
+tspan = (0.0, 10.0)
+prob = ODEProblem(lorenz_f!, u0, tspan, p)
+sol = solve(prob, Tsit5())
# Now the solution can be indexed as .x/y/z as well!
sol[10].x
```
In the example above, we used an `LArray` to define the
-intial state `u0` as well as the parameter vector `p`.
-The reminder of the ODE solution steps are are no different
+initial state `u0` as well as the parameter vector `p`.
+The reminder of the ODE solution steps are no different
that the original `DifferentialEquations` [tutorials](https://docs.sciml.ai/DiffEqDocs/stable/tutorials/ode_example/#Example-2:-Solving-Systems-of-Equations).
-Alternatively, we can use an immutable `SLVector` to
-implement the same equation. In this case, we need to
+Alternatively, we can use an immutable `SLVector` to
+implement the same equation. In this case, we need to
use the allocating form of the `OrdinaryDiffEq` API when
defining our model equation.
```julia
-LorenzVector = @SLVector (:x,:y,:z)
-LorenzParameterVector = @SLVector (:σ,:ρ,:β)
+LorenzVector = @SLVector (:x, :y, :z)
+LorenzParameterVector = @SLVector (:σ, :ρ, :β)
-function f(u,p,t)
- x = p.σ*(u.y-u.x)
- y = u.x*(p.ρ-u.z) - u.y
- z = u.x*u.y - p.β*u.z
- LorenzVector(x,y,z)
+function f(u, p, t)
+ x = p.σ * (u.y - u.x)
+ y = u.x * (p.ρ - u.z) - u.y
+ z = u.x * u.y - p.β * u.z
+ LorenzVector(x, y, z)
end
-u0 = LorenzVector(1.0,0.0,0.0)
-p = LorenzParameterVector(10.0,28.0,8/3)
-tspan = (0.0,10.0)
-prob = ODEProblem(f,u0,tspan,p)
-sol = solve(prob,Tsit5())
+u0 = LorenzVector(1.0, 0.0, 0.0)
+p = LorenzParameterVector(10.0, 28.0, 8 / 3)
+tspan = (0.0, 10.0)
+prob = ODEProblem(f, u0, tspan, p)
+sol = solve(prob, Tsit5())
```
-
diff --git a/docs/src/LArrays.md b/docs/src/LArrays.md
index 8043cbf..a055a6a 100644
--- a/docs/src/LArrays.md
+++ b/docs/src/LArrays.md
@@ -1,20 +1,20 @@
# LArrays
`LArrays` are fully mutable arrays with labels. There is no performance
-loss by using labelled indexing instead of purely numerical indexing.
+loss by using labelled indexing instead of purely numerical indexing.
Using the macro with values and labels generates the labelled array with
the given values:
-Users interested in using labelled elements in their arrays should also
-consider `ComponentArrays` from the
+Users interested in using labelled elements in their arrays should also
+consider `ComponentArrays` from the
[ComponentArrays.jl](https://docs.sciml.ai/ComponentArrays/stable/)
-library. `ComponentArrays` are well integrated into the SciML ecosystem.
+library. `ComponentArrays` are well integrated into the SciML ecosystem.
## `@LArray` and `@LVector` macros
-Macro constructors are convenient for building most `LArray` objects. An
-`@LArray` may be of arbitrary dimension while an `@LVector` is a
-one dimensional array.
+Macro constructors are convenient for building most `LArray` objects. An
+`@LArray` may be of arbitrary dimension, while an `@LVector` is a
+one dimensional array.
```@docs
@LArray
@@ -23,13 +23,14 @@ one dimensional array.
## `LArray` and `LVector` constructors
-The original constructors for `LArray`s and `LVector`s are as
-follows:
+The original constructors for `LArray`s and `LVector`s are as
+follows:
```@docs
LArray
LVector
```
+
## Manipulating `LArrays` and `LVectors`
User may want a list of the labels or keys in an `LArray` or `LVector`.
@@ -37,4 +38,4 @@ The `symbols(::LArray)` function returns a tuple of array labels.
```@docs
symbols
-```
\ No newline at end of file
+```
diff --git a/docs/src/NamedTuples_relation.md b/docs/src/NamedTuples_relation.md
index 131bdb5..2d00494 100644
--- a/docs/src/NamedTuples_relation.md
+++ b/docs/src/NamedTuples_relation.md
@@ -3,29 +3,29 @@
Julia's Base has NamedTuples in v0.7+. They are constructed as:
```julia
-p = (σ = 10.0,ρ = 28.0,β = 8/3)
+p = (σ = 10.0, ρ = 28.0, β = 8 / 3)
```
and they support `p[1]` and `p.σ` as well. The `LVector`, `SLVector`, `LArray`
and `SLArray` constructors also support named tuples as their arguments:
```julia
-julia> LVector((a=1, b=2))
+julia> LVector((a = 1, b = 2))
2-element LArray{Int64,1,(:a, :b)}:
1
2
-julia> SLVector((a=1, b=2))
+julia> SLVector((a = 1, b = 2))
2-element SLArray{Tuple{2},1,(:a, :b),Int64}:
1
2
-julia> LArray((2,2), (a=1, b=2, c=3, d=4))
+julia> LArray((2, 2), (a = 1, b = 2, c = 3, d = 4))
2×2 LArray{Int64,2,(:a, :b, :c, :d)}:
1 3
2 4
-julia> SLArray{Tuple{2,2}}((a=1, b=2, c=3, d=4))
+julia> SLArray{Tuple{2, 2}}((a = 1, b = 2, c = 3, d = 4))
2×2 SLArray{Tuple{2,2},2,(:a, :b, :c, :d),Int64}:
1 3
2 4
@@ -38,11 +38,11 @@ creates an iterator that is functionally the same as
for each label of the array.
There are some crucial differences between a labelled array and
-a named tuple. Labelled arrays can have any dimensions while
+a named tuple. Labelled arrays can have any dimensions, while
named tuples are always 1D. A named tuple can have different types
on each element, while an `SLArray` can only have one element
type and furthermore it has the actions of a static vector.
-As a result `SLArray` has less element type information, which
+As a result `SLArray` has less element type information, which
improves compilation speed while giving more vector functionality
than a NamedTuple. `LArray` also only has a single element type and,
-unlike a named tuple, is mutable.
\ No newline at end of file
+unlike a named tuple, is mutable.
diff --git a/docs/src/Note_labelled_slices.md b/docs/src/Note_labelled_slices.md
index 8381d1e..23cfbca 100644
--- a/docs/src/Note_labelled_slices.md
+++ b/docs/src/Note_labelled_slices.md
@@ -1,5 +1,5 @@
# Note: Labelled slices
-This functionality has been removed from LabelledArrays.jl, but can
-replicated with the same compile-time performance and indexing syntax
-using [DimensionalData.jl](https://github.com/rafaqz/DimensionalData.jl).
\ No newline at end of file
+This functionality has been removed from LabelledArrays.jl, but can
+be replicated with the same compile-time performance and indexing syntax
+using [DimensionalData.jl](https://github.com/rafaqz/DimensionalData.jl).
diff --git a/docs/src/SLArrays.md b/docs/src/SLArrays.md
index 28cd93b..e8327c1 100644
--- a/docs/src/SLArrays.md
+++ b/docs/src/SLArrays.md
@@ -1,14 +1,14 @@
# SLArrays
The `SLArray` and `SLVector` macros create static LabelledArrays.
-First the user would create the array type, then use that constructor to generate
+First, the user would create the array type, then use that constructor to generate
instances of the labelled array.
## `@SLArray` and `@SLVector` macros
-Macro constructors are convenient for building most `SLArray` objects. An
-`@SLArray` may be of arbitrary dimension while an `@SLVector` is a
-one dimensional array.
+Macro constructors are convenient for building most `SLArray` objects. An
+`@SLArray` may be of arbitrary dimension, while an `@SLVector` is a
+one dimensional array.
```@docs
@SLArray
@@ -32,4 +32,4 @@ The `symbols(::SLArray)` function returns a tuple of array labels.
```@docs
symbols(::SLArray)
-```
\ No newline at end of file
+```
diff --git a/docs/src/index.md b/docs/src/index.md
index 85acae3..3c2775d 100644
--- a/docs/src/index.md
+++ b/docs/src/index.md
@@ -16,66 +16,84 @@ Pkg.add("LabelledArrays")
## Contributing
-- Please refer to the
- [SciML ColPrac: Contributor's Guide on Collaborative Practices for Community Packages](https://github.com/SciML/ColPrac/blob/master/README.md)
- for guidance on PRs, issues, and other matters relating to contributing to SciML.
-- There are a few community forums:
- - the #diffeq-bridged channel in the [Julia Slack](https://julialang.org/slack/)
- - [JuliaDiffEq](https://gitter.im/JuliaDiffEq/Lobby) on Gitter
- - on the [Julia Discourse forums](https://discourse.julialang.org)
- - see also [SciML Community page](https://sciml.ai/community/)
+ - Please refer to the
+ [SciML ColPrac: Contributor's Guide on Collaborative Practices for Community Packages](https://github.com/SciML/ColPrac/blob/master/README.md)
+ for guidance on PRs, issues, and other matters relating to contributing to SciML.
+
+ - There are a few community forums:
+
+ + the #diffeq-bridged channel in the [Julia Slack](https://julialang.org/slack/)
+ + [JuliaDiffEq](https://gitter.im/JuliaDiffEq/Lobby) on Gitter
+ + on the [Julia Discourse forums](https://discourse.julialang.org)
+ + see also [SciML Community page](https://sciml.ai/community/)
## Reproducibility
+
```@raw html
The documentation of this SciML package was built using these direct dependencies,
```
+
```@example
using Pkg # hide
Pkg.status() # hide
```
+
```@raw html
and using this machine and Julia version.
```
+
```@example
using InteractiveUtils # hide
versioninfo() # hide
```
+
```@raw html
A more complete overview of all dependencies and their versions is also provided.
```
+
```@example
using Pkg # hide
-Pkg.status(;mode = PKGMODE_MANIFEST) # hide
+Pkg.status(; mode = PKGMODE_MANIFEST) # hide
```
+
```@raw html