[docs] fix doc linking of DenseAxisArray and SparseAxisArray (#4013)

Author: odow

docs/src/manual/constraints.md

@@ -1027,9 +1027,9 @@ julia> dual_start_value(con)
 
 Like [Variable containers](@ref), JuMP provides a mechanism for building groups
 of constraints compactly. References to these groups of constraints are returned
-in *containers*. Three types of constraint containers are supported: `Array`s,
-`DenseAxisArray`s, and `SparseAxisArray`s. We explain each of these in the
-following.
+in *containers*. Three types of constraint containers are supported: `Array`,
+[`Containers.DenseAxisArray`](@ref), and [`Containers.SparseAxisArray`](@ref).
+We explain each of these in the following.
 
 !!! tip
     You can read more about containers in the [Containers](@ref) section.
@@ -1075,14 +1075,14 @@ can determine at parse time that the indices are one-based integer ranges.
 Therefore `con[1:b]` will create an `Array`, but `con[a:b]` will not. A special
 case is `con[Base.OneTo(n)]` which will produce an `Array`. If JuMP cannot
 determine that the indices are one-based integer ranges (for example, in the case of
-`con[a:b]`), JuMP will create a `DenseAxisArray` instead.
+`con[a:b]`), JuMP will create a [`Containers.DenseAxisArray`](@ref) instead.
 
 ### DenseAxisArrays
 
-The syntax for constructing a [`DenseAxisArray`](@ref Containers.DenseAxisArray)
+The syntax for constructing a [`Containers.DenseAxisArray`](@ref)
 of constraints is very similar to the
-[syntax for constructing](@ref variable_jump_arrays) a `DenseAxisArray` of
-variables.
+[syntax for constructing](@ref variable_jump_arrays) a [`Containers.DenseAxisArray`](@ref)
+of variables.
 
 ```jldoctest constraint_jumparrays
 julia> model = Model();
@@ -1100,10 +1100,9 @@ And data, a 2×2 Matrix{ConstraintRef{Model, MathOptInterface.ConstraintIndex{Ma
 
 ### SparseAxisArrays
 
-The syntax for constructing a
-[`SparseAxisArray`](@ref Containers.SparseAxisArray) of constraints is very
-similar to the [syntax for constructing](@ref variable_sparseaxisarrays) a
-`SparseAxisArray` of variables.
+The syntax for constructing a [`Containers.SparseAxisArray`](@ref) of
+constraints is very similar to the [syntax for constructing](@ref variable_sparseaxisarrays)
+a [`Containers.SparseAxisArray`](@ref) of variables.
 
 ```jldoctest constraint_jumparrays
 julia> model = Model();

docs/src/manual/containers.md

@@ -155,7 +155,7 @@ And data, a 2×2 Matrix{Tuple{Int64, Symbol}}:
 
 ### Slicing
 
-DenseAxisArrays can be sliced
+A [`Containers.DenseAxisArray`](@ref) can be sliced:
 ```jldoctest containers_dense
 julia> x[:, :A]
 1-dimensional DenseAxisArray{Tuple{Int64, Symbol},1,...} with index sets:
@@ -195,7 +195,7 @@ julia> axes(x)
 
 ### Broadcasting
 
-Broadcasting over a DenseAxisArray returns a DenseAxisArray
+Broadcasting over a [`Containers.DenseAxisArray`](@ref) returns [`Containers.DenseAxisArray`](@ref):
 ```jldoctest containers_dense
 julia> swap(x::Tuple) = (last(x), first(x))
 swap (generic function with 1 method)
@@ -229,8 +229,8 @@ julia> x.data
 
 ### Tables
 
-Use [`Containers.rowtable`](@ref) to convert the `DenseAxisArray` into a
-[Tables.jl](https://github.com/JuliaData/Tables.jl) compatible
+Use [`Containers.rowtable`](@ref) to convert a [`Containers.DenseAxisArray`](@ref)
+into a [Tables.jl](https://github.com/JuliaData/Tables.jl) compatible
 `Vector{<:NamedTuple}`:
 
 ```jldoctest containers_dense
@@ -331,15 +331,17 @@ julia> for key in eachindex(y)
 ```
 
 !!! warning
-    If you use a macro to construct a `SparseAxisArray`, then the iteration
-    order is row-major, that is, indices are varied from right to left. As an
-    example, when iterating over `x` above, the `j` index is iterated, keeping
-    `i` constant. This order is in contrast to `Base.Array`s, which iterate in
-    column-major order, that is, by varying indices from left to right.
+    If you use a macro to construct a [`Containers.SparseAxisArray`](@ref), then
+    the iteration order is row-major, that is, indices are varied from right to
+    left. As an example, when iterating over `x` above, the `j` index is
+    iterated, keeping `i` constant. This order is in contrast to `Base.Array`,
+    which iterates in column-major order, that is, by varying indices from left
+    to right.
 
 ### Broadcasting
 
-Broadcasting over a SparseAxisArray returns a SparseAxisArray
+Broadcasting over a [`Containers.SparseAxisArray`](@ref) returns a
+[`Containers.SparseAxisArray`](@ref):
 
 ```jldoctest containers_sparse
 julia> swap(x::Tuple) = (last(x), first(x))
@@ -353,8 +355,8 @@ JuMP.Containers.SparseAxisArray{Tuple{Symbol, Int64}, 1, Tuple{Int64}} with 2 en
 
 ### Tables
 
-Use [`Containers.rowtable`](@ref) to convert the `SparseAxisArray` into a
-[Tables.jl](https://github.com/JuliaData/Tables.jl) compatible
+Use [`Containers.rowtable`](@ref) to convert the [`Containers.SparseAxisArray`](@ref)
+into a [Tables.jl](https://github.com/JuliaData/Tables.jl) compatible
 `Vector{<:NamedTuple}`:
 
 ```jldoctest containers_sparse

docs/src/manual/variables.md

@@ -800,8 +800,8 @@ x
 JuMP provides a mechanism for creating collections of variables in three types
 of data structures, which we refer to as *containers*.
 
-The three types are `Array`s, `DenseAxisArray`s, and `SparseAxisArray`s. We
-explain each of these in the following.
+The three types are `Array`, [`Containers.DenseAxisArray`](@ref), and
+[`Containers.SparseAxisArray`](@ref). We explain each of these in the following.
 
 !!! tip
     You can read more about containers in the [Containers](@ref) section.
@@ -850,7 +850,7 @@ JuMP will form an `Array` of JuMP variables when it can determine at compile
 time that the indices are one-based integer ranges. Therefore `x[1:b]` will
 create an `Array` of JuMP variables, but `x[a:b]` will not. If JuMP cannot
 determine that the indices are one-based integer ranges (for example, in the case of
-`x[a:b]`), JuMP will create a `DenseAxisArray` instead.
+`x[a:b]`), JuMP will create a [`Containers.DenseAxisArray`](@ref) instead.
 
 ### [DenseAxisArrays](@id variable_jump_arrays)
 
@@ -859,7 +859,7 @@ ranges. For example, we may want to create a variable indexed by the name of a
 product or a location. The syntax is the same as that above, except with an
 arbitrary vector as an index as opposed to a one-based range. The biggest
 difference is that instead of returning an `Array` of JuMP variables, JuMP will
-return a `DenseAxisArray`. For example:
+return a [`Containers.DenseAxisArray`](@ref). For example:
 ```jldoctest variables_jump_arrays
 julia> model = Model();
 
@@ -872,7 +872,7 @@ And data, a 2×2 Matrix{VariableRef}:
  x[2,A]  x[2,B]
 ```
 
-DenseAxisArrays can be indexed and sliced as follows:
+A [`Containers.DenseAxisArray`](@ref) can be indexed and sliced as follows:
 ```jldoctest variables_jump_arrays
 julia> x[1, :A]
 x[1,A]
@@ -908,7 +908,7 @@ And data, a 2×2 Matrix{Float64}:
 
 ### [SparseAxisArrays](@id variable_sparseaxisarrays)
 
-The third container type that JuMP natively supports is `SparseAxisArray`.
+The third container type that JuMP natively supports is [`Containers.SparseAxisArray`](@ref).
 These arrays are created when the indices do not form a rectangular set.
 For example, this applies when indices have a dependence upon previous
 indices (called *triangular indexing*). JuMP supports this as follows:
@@ -996,9 +996,10 @@ using the filtering syntax.
 
 When creating a container of JuMP variables, JuMP will attempt to choose the
 tightest container type that can store the JuMP variables. Thus, it will prefer
-to create an Array before a DenseAxisArray and a DenseAxisArray before a
-SparseAxisArray. However, because this happens at compile time, JuMP does not
-always make the best choice. To illustrate this, consider the following example:
+to create an `Array` before a [`Containers.DenseAxisArray`](@ref) and a
+[`Containers.DenseAxisArray`](@ref) before a [`Containers.SparseAxisArray`](@ref).
+However, because this happens at compile time, JuMP does not always make the
+best choice. To illustrate this, consider the following example:
 ```jldoctest variable_force_container
 julia> model = Model();
 
@@ -1014,8 +1015,8 @@ And data, a 2-element Vector{VariableRef}:
 ```
 Since the value (and type) of `A` is unknown at parsing time, JuMP is unable to
 infer that `A` is a one-based integer range. Therefore, JuMP creates a
-`DenseAxisArray`, even though it could store these two variables in a standard
-one-dimensional `Array`.
+[`Containers.DenseAxisArray`](@ref), even though it could store these two
+variables in a standard one-dimensional `Array`.
 
 We can share our knowledge that it is possible to store these JuMP variables as
 an array by setting the `container` keyword:
@@ -1025,7 +1026,7 @@ julia> @variable(model, y[A], container=Array)
  y[1]
  y[2]
 ```
-JuMP now creates a vector of JuMP variables instead of a DenseAxisArray.
+JuMP now creates a `Vector` of JuMP variables instead of a [`Containers.DenseAxisArray](@ref).
 Choosing an invalid container type will throw an error.
 
 ### User-defined containers
@@ -1119,7 +1120,7 @@ nonnegative.
 
 !!! note
     `x` must be a square 2-dimensional `Array` of JuMP variables; it cannot be a
-    DenseAxisArray or a SparseAxisArray.
+    [`Containers.DenseAxisArray`](@ref) or a [`Containers.SparseAxisArray`](@ref).
 
 Use [`VariableInSetRef`](@ref) to obtain the associated constraint reference:
 

docs/src/tutorials/getting_started/design_patterns_for_larger_models.jl

@@ -612,8 +612,9 @@ Solve the knapsack problem and return the optimal primal solution
 
 ## Returns
 
- * If an optimal solution exists: a `JuMP.DenseAxisArray` that maps the `String`
-   name of each object to the number of objects to pack into the knapsack.
+ * If an optimal solution exists: a `JuMP.Containers.DenseAxisArray` that maps
+   the `String` name of each object to the number of objects to pack into the
+   knapsack.
  * Otherwise, `nothing`, indicating that the problem does not have an optimal
    solution.
 

docs/src/tutorials/getting_started/getting_started_with_JuMP.jl

@@ -336,7 +336,7 @@ end                         #hide
 
 # JuMP provides data structures for adding collections of variables to a model.
 # These data structures are referred to as _containers_ and are of three types:
-# `Arrays`, `DenseAxisArrays`, and `SparseAxisArrays`.
+# `Array`, [`Containers.DenseAxisArray`](@ref), and [`Containers.SparseAxisArray`](@ref).
 
 # #### Arrays
 
@@ -367,17 +367,17 @@ u = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19];
 
 # #### DenseAxisArrays
 
-# `DenseAxisArrays` are used when the indices are not one-based integer ranges.
-# The syntax is similar except with an arbitrary vector as an index as opposed
-# to a one-based range:
+# [`Containers.DenseAxisArray`](@ref) is used when the indices are not one-based
+# integer ranges. The syntax is similar, except with an arbitrary vector as an
+# index as opposed to a one-based range:
 
 @variable(model, z[i = 2:3, j = 1:2:3] >= 0)
 
 # Indices do not have to be integers. They can be any Julia type:
 
 @variable(model, w[1:5, ["red", "blue"]] <= 1)
 
-# Index elements in a `DenseAxisArray` as follows:
+# Index elements in a [`Containers.DenseAxisArray`](@ref) as follows:
 
 z[2, 1]
 
@@ -389,9 +389,9 @@ w[2:3, ["red", "blue"]]
 
 # #### SparseAxisArrays
 
-# `SparseAxisArrays` are created when the indices do not form a Cartesian product.
-# For example, this applies when indices have a dependence upon previous indices
-# (called triangular indexing):
+# A [`Containers.SparseAxisArray`](@ref) is created when the indices do not form
+# a Cartesian product. For example, this applies when indices have a dependence
+# upon previous indices (called triangular indexing):
 
 @variable(model, u[i = 1:2, j = i:3])
 
@@ -401,7 +401,7 @@ w[2:3, ["red", "blue"]]
 
 @variable(model, v[i = 1:9; mod(i, 3) == 0])
 
-# Index elements in a `DenseAxisArray` as follows:
+# Index elements in a [`Containers.SparseAxisArray`](@ref) as follows:
 
 u[1, 2]
 
@@ -446,9 +446,10 @@ model = Model()
 
 # ### [Containers](@id tutorial_constraint_container)
 
-# Just as we had containers for variables, JuMP also provides `Arrays`,
-# `DenseAxisArrays`, and `SparseAxisArrays` for storing collections of
-# constraints. Examples for each container type are given below.
+# Just as we had containers for variables, JuMP also provides `Array`,
+# [`Containers.DenseAxisArray`](@ref), and [`Containers.SparseAxisArray`](@ref)
+# for storing collections of constraints. Examples for each container type are
+# given below.
 
 # #### Arrays
 
@@ -458,13 +459,13 @@ model = Model()
 
 # #### DenseAxisArrays
 
-# Create an `DenseAxisArray` of constraints:
+# Create a [`Containers.DenseAxisArray`](@ref) of constraints:
 
 @constraint(model, [i = 1:2, j = 2:3], i * x <= j + 1)
 
 # #### SparseAxisArrays
 
-# Create an `SparseAxisArray` of constraints:
+# Create a [`Containers.SparseAxisArray`](@ref) of constraints:
 
 @constraint(model, [i = 1:2, j = 1:2; i != j], i * x <= j + 1)
 

docs/src/tutorials/linear/diet.jl

@@ -118,8 +118,8 @@ set_silent(model)
 @variable(model, x[foods.name] >= 0)
 
 # To simplify things later on, we store the vector as a new column `x` in the
-# DataFrame `foods`. Since `x` is a `DenseAxisArray`, we first need to convert
-# it to an `Array`:
+# DataFrame `foods`. Since `x` is a [`Containers.DenseAxisArray`](@ref), we
+# first need to convert it to an `Array`:
 
 foods.x = Array(x)