Clean Up and Simplify Dependence on Infinite Parameters (#393)

* Updated source code

* More updates and fixes

* doc fix

* test fixes

* doctest fixes

* minor fixes

* minor fixes

Author: pulsipher

docs/src/develop/extensions.md

@@ -516,12 +516,12 @@ struct DiscreteVarianceData <: AbstractMeasureData
     label::DataType
     # constructor
     function DiscreteVarianceData(
-        parameter_refs::Union{GeneralVariableRef, AbstractArray{<:GeneralVariableRef}},
+        parameter_refs::Union{GeneralVariableRef, Array{<:GeneralVariableRef}},
         supports::Vector,
         label::DataType = InfiniteOpt.generate_unique_label()
         )
         # convert input as necessary to proper array format
-        if parameter_refs isa AbstractArray
+        if parameter_refs isa Array
             parameter_refs = convert(Vector, parameter_refs)
             supports = [convert(Vector, arr) for arr in supports]
         end
@@ -631,7 +631,7 @@ variance measures more convenient:
 ```jldoctest measure_data; output = false
 function variance(
     expr::Union{JuMP.GenericAffExpr, GeneralVariableRef},
-    params::Union{GeneralVariableRef, AbstractArray{GeneralVariableRef}};
+    params::Union{GeneralVariableRef, Array{GeneralVariableRef}};
     name::String = "Var", 
     num_supports::Int = 10,
     use_existing::Bool = false

docs/src/examples/Stochastic Optimization/farmer.jl

@@ -80,7 +80,7 @@ model = InfiniteModel(Ipopt.Optimizer)
 set_optimizer_attribute(model, "print_level", 0);
 
 # Now let's define the infinite parameters using [`@infinite_parameter`](@ref):
-@infinite_parameter(model, ξ[c in C] ~ Ξ[c], num_supports = num_scenarios)
+@infinite_parameter(model, ξ[c in C] ~ Ξ[c], num_supports = num_scenarios, container = Array)
 
 # !!! note
 #     Behind the scenes, an amount of random samples equal to `num_scenarios` will 

docs/src/guide/derivative.md

@@ -27,7 +27,9 @@ julia> @infinite_parameter(model, t in [0, 10],
 
 julia> @infinite_parameter(model, ξ ~ Uniform(-1, 1));
 
-julia> @variable(model, y, Infinite(t, ξ));
+julia> @infinite_parameter(model, x in [-1, 1]);
+
+julia> @variable(model, y, Infinite(t, x, ξ));
 
 julia> @variable(model, q, Infinite(t));
 ```
@@ -45,24 +47,28 @@ scenes all the appropriate calculus will be applied, creating derivative variabl
 as needed. For example, we can define the following:
 ```jldoctest deriv_basic 
 julia> d1 = deriv(y, t)
-∂/∂t[y(t, ξ)]
+∂/∂t[y(t, x, ξ)]
 
-julia> d2 = ∂(y, t, ξ)
-∂/∂ξ[∂/∂t[y(t, ξ)]]
+julia> d2 = ∂(y, t, x)
+∂/∂x[∂/∂t[y(t, x, ξ)]]
 
 julia> d3 = @∂(q, t^2) # the macro version allows the `t^2` syntax
 d²/dt²[q(t)]
 
 julia> d_expr = deriv(y * q - 2t, t)
-∂/∂t[y(t, ξ)]*q(t) + d/dt[q(t)]*y(t, ξ) - 2
+∂/∂t[y(t, x, ξ)]*q(t) + d/dt[q(t)]*y(t, x, ξ) - 2
 ```
 Thus, we can define derivatives in a variety of forms according to the problem at 
-hand. The last example even shows how the product rule is correctly applied. 
+hand. The last example even shows how the product rule is correctly applied.
 
 !!! note 
     For convenience in making more compact code we provide [`∂`](@ref) 
     as an alias for [`deriv`](@ref).
 
+!!! note
+    Derivatives taken with respect to dependent infinite parameters are not
+    supported.
+
 Also, notice that the appropriate symbolic calculus is applied to infinite 
 parameters. For example, we could also compute:
 ```jldoctest deriv_basic 
@@ -170,7 +176,7 @@ More detailed information on `JuMP.VariableInfo` is provided in the
 Now that we have our variable information we can make a derivative using 
 [`build_derivative`](@ref):
 ```jldoctest deriv_basic 
-julia> d = build_derivative(error, info, y, ξ, 1);
+julia> d = build_derivative(error, info, y, x, 1);
 
 julia> d isa Derivative
 true
@@ -184,14 +190,14 @@ will add the [`Derivative`](@ref) object and return `GeneralVariableRef` pointin
 to it that we can use in `InfiniteOpt` expressions:
 ```jldoctest deriv_basic 
 julia> dref = add_derivative(model, d)
-∂/∂ξ[y(t, ξ)]
+∂/∂x[y(t, x, ξ)]
 ```
 This will also create any appropriate information based constraints (e.g., lower 
 bounds).
 
 Finally, we note that higher order derivatives by changing the order argument:
 ```jldoctest deriv_basic 
-julia> d = build_derivative(error, info, y, ξ, 3); # 3rd order derivative
+julia> d = build_derivative(error, info, y, x, 3); # 3rd order derivative
 ```
 
 ### Macro Definition 
@@ -208,7 +214,7 @@ of 1 with an initial guess of 0 and assign it to an alias
 `GeneralVariableRef` called `dydt2`:
 ```jldoctest deriv_basic 
 julia> @variable(model, dydt2 >= 1, Deriv(y, t, 2), start = 0)
-dydt2(t, ξ)
+dydt2(t, x, ξ)
 ```
 This will also support anonymous definition and multi-dimensional definition. 
 Please see [Macro Variable Definition](@ref) for more information.
@@ -228,17 +234,17 @@ derivative definition, handling the nesting as appropriate. For example, we can
 "define" ``\frac{\partial^2 y(t, \xi)}{\partial t^2}`` again:
 ```jldoctest deriv_basic 
 julia> @deriv(d1, t) # recall `d1 = deriv(y, t)`
-dydt2(t, ξ)
+dydt2(t, x, ξ)
 
 julia> @deriv(y, t^2)
-dydt2(t, ξ)
+dydt2(t, x, ξ)
 ```
 Notice that the derivative references all point to the same derivative object we 
 defined up above with its alias name `dydt2`. This macro can also tackle complex 
 expressions using the appropriate calculus such as:
 ```jldoctest deriv_basic 
 julia> @deriv(∫(y, ξ) * q, t)
-d/dt[∫{ξ ∈ [-1, 1]}[y(t, ξ)]]*q(t) + d/dt[q(t)]*∫{ξ ∈ [-1, 1]}[y(t, ξ)]
+d/dt[∫{ξ ∈ [-1, 1]}[y(t, x, ξ)]]*q(t) + d/dt[q(t)]*∫{ξ ∈ [-1, 1]}[y(t, x, ξ)]
 ```
 Thus, demonstrating the convenience of using `@deriv`.
 
@@ -457,18 +463,18 @@ We can build these relations for a particular derivative via [`evaluate`](@ref).
 For example, let's build evaluation equations for `d1`:
 ```jldoctest deriv_basic
 julia> d1 
-∂/∂t[y(t, ξ)]
+∂/∂t[y(t, x, ξ)]
 
 julia> fill_in_supports!(t, num_supports = 5) # add supports first
 
 julia> evaluate(d1)
 
 julia> derivative_constraints(d1)
 4-element Vector{InfOptConstraintRef}:
- 2.5 ∂/∂t[y(t, ξ)](0, ξ) + y(0, ξ) - y(2.5, ξ) = 0, ∀ ξ ~ Uniform
- 2.5 ∂/∂t[y(t, ξ)](2.5, ξ) + y(2.5, ξ) - y(5, ξ) = 0, ∀ ξ ~ Uniform
- 2.5 ∂/∂t[y(t, ξ)](5, ξ) + y(5, ξ) - y(7.5, ξ) = 0, ∀ ξ ~ Uniform
- 2.5 ∂/∂t[y(t, ξ)](7.5, ξ) + y(7.5, ξ) - y(10, ξ) = 0, ∀ ξ ~ Uniform
+ 2.5 ∂/∂t[y(t, x, ξ)](0, x, ξ) + y(0, x, ξ) - y(2.5, x, ξ) = 0, ∀ ξ ~ Uniform, x ∈ [-1, 1]
+ 2.5 ∂/∂t[y(t, x, ξ)](2.5, x, ξ) + y(2.5, x, ξ) - y(5, x, ξ) = 0, ∀ ξ ~ Uniform, x ∈ [-1, 1]
+ 2.5 ∂/∂t[y(t, x, ξ)](5, x, ξ) + y(5, x, ξ) - y(7.5, x, ξ) = 0, ∀ ξ ~ Uniform, x ∈ [-1, 1]
+ 2.5 ∂/∂t[y(t, x, ξ)](7.5, x, ξ) + y(7.5, x, ξ) - y(10, x, ξ) = 0, ∀ ξ ~ Uniform, x ∈ [-1, 1]
 ```
 Note that we made sure `t` had supports first over which we could carry out the 
 evaluation, otherwise an error would have been thrown. Moreover, once the 
@@ -478,15 +484,15 @@ evaluation was completed we were able to access the auxiliary equations via
 We can also, add the necessary auxiliary equations for all the derivatives in the 
 model if we call [`evaluate_all_derivatives!`](@ref):
 ```jldoctest deriv_basic
-julia> fill_in_supports!(ξ, num_supports = 4) # add supports first
+julia> fill_in_supports!(x, num_supports = 4) # add supports first
 
 julia> evaluate_all_derivatives!(model)
 
 julia> derivative_constraints(dydt2)
 3-element Vector{InfOptConstraintRef}:
- 6.25 dydt2(0, ξ) - y(0, ξ) + 2 y(2.5, ξ) - y(5, ξ) = 0, ∀ ξ ~ Uniform
- 6.25 dydt2(2.5, ξ) - y(2.5, ξ) + 2 y(5, ξ) - y(7.5, ξ) = 0, ∀ ξ ~ Uniform
- 6.25 dydt2(5, ξ) - y(5, ξ) + 2 y(7.5, ξ) - y(10, ξ) = 0, ∀ ξ ~ Uniform
+ 6.25 dydt2(0, x, ξ) - y(0, x, ξ) + 2 y(2.5, x, ξ) - y(5, x, ξ) = 0, ∀ ξ ~ Uniform, x ∈ [-1, 1]
+ 6.25 dydt2(2.5, x, ξ) - y(2.5, x, ξ) + 2 y(5, x, ξ) - y(7.5, x, ξ) = 0, ∀ ξ ~ Uniform, x ∈ [-1, 1]
+ 6.25 dydt2(5, x, ξ) - y(5, x, ξ) + 2 y(7.5, x, ξ) - y(10, x, ξ) = 0, ∀ ξ ~ Uniform, x ∈ [-1, 1]
 ```
 
 Finally, we note that once derivative constraints have been added to the 
@@ -496,10 +502,10 @@ and a warning will be thrown to indicate such:
 ```jldoctest deriv_basic
 julia> derivative_constraints(d1)
 4-element Vector{InfOptConstraintRef}:
- 2.5 ∂/∂t[y(t, ξ)](0, ξ) + y(0, ξ) - y(2.5, ξ) = 0, ∀ ξ ~ Uniform
- 2.5 ∂/∂t[y(t, ξ)](2.5, ξ) + y(2.5, ξ) - y(5, ξ) = 0, ∀ ξ ~ Uniform
- 2.5 ∂/∂t[y(t, ξ)](5, ξ) + y(5, ξ) - y(7.5, ξ) = 0, ∀ ξ ~ Uniform
- 2.5 ∂/∂t[y(t, ξ)](7.5, ξ) + y(7.5, ξ) - y(10, ξ) = 0, ∀ ξ ~ Uniform
+ 2.5 ∂/∂t[y(t, x, ξ)](0, x, ξ) + y(0, x, ξ) - y(2.5, x, ξ) = 0, ∀ ξ ~ Uniform, x ∈ [-1, 1]
+ 2.5 ∂/∂t[y(t, x, ξ)](2.5, x, ξ) + y(2.5, x, ξ) - y(5, x, ξ) = 0, ∀ ξ ~ Uniform, x ∈ [-1, 1]
+ 2.5 ∂/∂t[y(t, x, ξ)](5, x, ξ) + y(5, x, ξ) - y(7.5, x, ξ) = 0, ∀ ξ ~ Uniform, x ∈ [-1, 1]
+ 2.5 ∂/∂t[y(t, x, ξ)](7.5, x, ξ) + y(7.5, x, ξ) - y(10, x, ξ) = 0, ∀ ξ ~ Uniform, x ∈ [-1, 1]
 
 julia> add_supports(t, 0.2)
 ┌ Warning: Support/method changes will invalidate existing derivative evaluation constraints that have been added to the InfiniteModel. Thus, these are being deleted.
@@ -519,7 +525,7 @@ First, let's overview the basic object inquiries: [`derivative_argument`](@ref),
 [`derivative_method`](@ref), and [`name`](@ref JuMP.name(::DecisionVariableRef)):
 ```jldoctest deriv_basic
 julia> derivative_argument(dydt2) # get the variable the derivative operates on
-y(t, ξ)
+y(t, x, ξ)
 
 julia> operator_parameter(dydt2) # get the parameter the operator is taken with respect to
 t
@@ -553,10 +559,10 @@ Also, since derivatives are analogous to infinite variables, they inherit many
 of the same queries including [`parameter_refs`](@ref):
 ```jldoctest deriv_basic
 julia> parameter_refs(d1)
-(t, ξ)
+(t, x, ξ)
 
 julia> parameter_refs(derivative_argument(d1))
-(t, ξ)
+(t, x, ξ)
 ```
 Since derivatives simply inherit their infinite parameter dependencies from the 
 argument variable, the above lines are equivalent.
@@ -573,7 +579,7 @@ julia> lower_bound(dydt2)
 1.0
 
 julia> LowerBoundRef(dydt2)
-dydt2(t, ξ) ≥ 1, ∀ t ∈ [0, 10], ξ ~ Uniform
+dydt2(t, x, ξ) ≥ 1, ∀ t ∈ [0, 10], ξ ~ Uniform, x ∈ [-1, 1]
 
 julia> has_upper_bound(dydt2)
 false 
@@ -590,13 +596,13 @@ julia> num_derivatives(model)
 
 julia> all_derivatives(model)
 7-element Vector{GeneralVariableRef}:
- ∂/∂t[y(t, ξ)]
- ∂/∂ξ[∂/∂t[y(t, ξ)]]
+ ∂/∂t[y(t, x, ξ)]
+ ∂/∂x[∂/∂t[y(t, x, ξ)]]
  d²/dt²[q(t)]
  d/dt[q(t)]
- ∂/∂ξ[y(t, ξ)]
- dydt2(t, ξ)
- d/dt[∫{ξ ∈ [-1, 1]}[y(t, ξ)]]
+ ∂/∂x[y(t, x, ξ)]
+ dydt2(t, x, ξ)
+ ∂/∂t[∫{ξ ∈ [-1, 1]}[y(t, x, ξ)]]
 ```
 
 ## Modification Methods 
@@ -623,7 +629,7 @@ julia> fix(dydt2, 42, force = true)
 julia> fix_value(dydt2) 
 42.0
 
-julia> set_start_value_function(dydt2, (t, xi) -> t + xi)
+julia> set_start_value_function(dydt2, (t, x, xi) -> t + x+ xi)
 
 julia> unfix(dydt2)
 

docs/src/guide/measure.md

@@ -215,7 +215,7 @@ julia> md_x = DiscreteMeasureData(x, 0.25 * ones(4), [[0.25, 0.25], [0.25, 0.75]
 ```
 where `md_x` cuts the domain into four 0.5-by-0.5 squares, and evaluates the 
 integrand on the center of these squares. Note that for multivariate parameters,  
-each support point should be an `AbstractArray` that stores the value at each dimension. 
+each support point should be an `Array` that stores the value at each dimension. 
 
 In addition to the intuitive [`DiscreteMeasureData`], another type of measure data  
 object is [`FunctionalDiscreteMeasureData`](@ref). This type captures measure data 

docs/src/guide/optimize.md

@@ -163,7 +163,7 @@ We can also query the expressions via
 [`transformation_expression`](@ref transformation_expression(::JuMP.AbstractJuMPScalar)):
 ```jldoctest optimize
 julia> transformation_expression(z - y^2 + 3) # infinite expression
-10-element Vector{AbstractJuMPScalar}:
+10-element Vector{Union{Real, AbstractJuMPScalar}}:
  -y(0.0)² + z + 3
  -y(1.11111111111)² + z + 3
  -y(2.22222222222)² + z + 3

docs/src/guide/parameter.md

@@ -295,20 +295,7 @@ julia> θ = @infinite_parameter(model, [1:2] ~ dist, num_supports = 3, base_name
 ```
 
 ### Containers for Multi-Dimensional Parameters
-Because we build on JuMP, we can use any indices we like when making containers 
-(e.g., arrays) for multi-dimensional parameters. For example, we can define:
-```jldoctest; setup = :(using InfiniteOpt; model= InfiniteModel())
-julia> @infinite_parameter(model, x[i = [:a, :b]] in [0, 1])
-1-dimensional DenseAxisArray{GeneralVariableRef,1,...} with index sets:
-    Dimension 1, [:a, :b]
-And data, a 2-element Vector{GeneralVariableRef}:
- x[a]
- x[b]
-```
-
-See 
-[`JuMP`'s documentation on containers](https://jump.dev/JuMP.jl/v1/manual/containers/) 
-for more information.
+Unlike other modelling objects, only `Array` containers are supported for infinite parameters. 
 
 ## Supports
 For an infinite parameter, its supports are a finite set of points that the 
@@ -452,7 +439,7 @@ In this section we introduce automatic support generation for defined
 parameters with no associated supports. This can be done using the 
 [`fill_in_supports!`](@ref) functions. [`fill_in_supports!`](@ref) can take as 
 argument a [`GeneralVariableRef`](@ref) or an 
-`AbstractArray{<:GeneralVariableRef}`, in which case it will generate 
+`Array{<:GeneralVariableRef}`, in which case it will generate 
 supports for the associated infinite parameter. Alternatively, 
 [`fill_in_supports!`](@ref) can also take an [`InfiniteModel`](@ref) as an 
 argument, in which case it will generate supports for all infinite parameters