Vectorized bounds on variables

[hdavid16]

It would be nice to be able to do the following to set bounds on variable arrays (or other variable containers):

@variable(m, [1,2] .<= x[1:2] .<= [3,4])

This currently throws a LoadError indicating that <= should be used instead. Using <= instead of the vectorized inequality instructs the user with "Instead of @variable(model, x[1:2] >= lb), do @variable(model, x[i=1:2] >= lb[i]). Alternatively, create the variable without bounds, then call set_lower_bound.(x, lb)." This makes perfect sense. Would it make sense to add the capability of passing arrays as variable bounds to generate bounded variables on the fly?

[odow]

Discussed before:
x-ref #2056
x-ref #2725

If I recall correctly, it was a little finicky to get this to work correctly due to some internals in the macros. But we should take another look at this.

[odow]

I took another look at this, it's actually surprisingly tricky to get working inside the build loop given we process each variable one-by-one.

The easiest approach is probably for

@variable(model, x .>= a)
# becomes
@variable(model, x)
set_lower_bound.(x, a)

[hdavid16]

I've given some thought to this in the past few days and I feel perfectly comfortable following the instruction printed in the LoadError.

Instead of vectorizing,

@variable(m, [1,2] .<= x[1:2] .<= [3,4])

It's really simple to just do,

@variable(m, [1,2][i] <= x[i=1:2] <= [3,4][i])

I mean, you save a few characters of typing the first way, but it's probably not worth it if it's too complicated.

[odow]

We can do two things to improve this:

• Throw a proper error in the broadcasting case
• Reformat the existing error to be more readable.

I'm about to push a PR that will make it:

julia> using JuMP

julia> model = Model()
A JuMP Model
Feasibility problem with:
Variables: 0
Model mode: AUTOMATIC
CachingOptimizer state: NO_OPTIMIZER
Solver name: No optimizer attached.

julia> a = [1, 2]
2-element Vector{Int64}:
 1
 2

julia> @variable(model, x[1:2] .>= a)
ERROR: At REPL[31]:1: `@variable(model, x[1:2] .>= a)`: Passing arrays as variable bounds is not supported.

Instead of:
```julia
@variable(model, x[1:2] >= lb)
```
use
```julia
@variable(model, x[i=1:2] >= lb[i])
```
or
```julia
@variable(model, x[1:2])
set_lower_bound.(x, lb)
```

Stacktrace:
  [1] error(::String, ::String)
    @ Base ./error.jl:42
  [2] _macro_error(macroname::Symbol, args::Tuple{Symbol, Expr}, source::LineNumberNode, str::String)
    @ JuMP ~/.julia/dev/JuMP/src/macros.jl:1570
  [3] (::JuMP.var"#_error#101"{LineNumberNode})(str::String)
    @ JuMP ~/.julia/dev/JuMP/src/macros.jl:1839
  [4] build_variable(::JuMP.var"#_error#101"{LineNumberNode}, ::VariableInfo{Vector{Int64}, Float64, Float64, Float64}; kwargs::Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
    @ JuMP ~/.julia/dev/JuMP/src/macros.jl:1442
  [5] build_variable(::Function, ::VariableInfo{Vector{Int64}, Float64, Float64, Float64})
    @ JuMP ~/.julia/dev/JuMP/src/macros.jl:1425
  [6] (::var"#27#28")(3301::Int64)
    @ Main ~/.julia/dev/JuMP/src/Containers/macro.jl:304
  [7] #37
    @ ~/.julia/dev/JuMP/src/Containers/container.jl:72 [inlined]
  [8] iterate
    @ ./generator.jl:47 [inlined]
  [9] collect(itr::Base.Generator{JuMP.Containers.VectorizedProductIterator{Tuple{Base.OneTo{Int64}}}, JuMP.Containers.var"#37#38"{var"#27#28"}})
    @ Base ./array.jl:678
 [10] map(f::Function, A::JuMP.Containers.VectorizedProductIterator{Tuple{Base.OneTo{Int64}}})
    @ Base ./abstractarray.jl:2323
 [11] container
    @ ~/.julia/dev/JuMP/src/Containers/container.jl:72 [inlined]
 [12] container(f::Function, indices::JuMP.Containers.VectorizedProductIterator{Tuple{Base.OneTo{Int64}}})
    @ JuMP.Containers ~/.julia/dev/JuMP/src/Containers/container.jl:66
 [13] macro expansion
    @ ~/.julia/dev/JuMP/src/macros.jl:142 [inlined]
 [14] top-level scope
    @ REPL[31]:1

[hdavid16]

So is it that passing arrays is not supported or vectorization is not supported when creating variables? You are still passing an array when you use the indexing form.

[odow]

How about "Passing arrays as ... without indexing them is not supported."?

If you index them you won't get the error message, so it's a moot point.

[hdavid16]

Yes. That sounds better to me.