Skip to content

Commit 2ef1a96

Browse files
blegatblegat
committed
Rename allocate-load API
1 parent 6b237a3 commit 2ef1a96

File tree

3 files changed

+88
-86
lines changed

3 files changed

+88
-86
lines changed

‎src/Utilities/copy.jl

Lines changed: 58 additions & 58 deletions
Original file line numberDiff line numberDiff line change
@@ -20,39 +20,39 @@ Base.delete!(idxmap::IndexMap, ci::MOI.ConstraintIndex) = delete!(idxmap.conmap,
2020
Base.keys(idxmap::IndexMap) = Iterators.flatten((keys(idxmap.varmap), keys(idxmap.conmap)))
2121

2222
"""
23-
passattributes!(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::Bool, idxmap::IndexMap, passattr!::Function=MOI.set)
23+
pass_attributes(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::Bool, idxmap::IndexMap, passattr!::Function=MOI.set)
2424
2525
Pass the model attributes from the model `src` to the model `dest` using `canpassattr` to check if the attribute can be passed and `passattr!` to pass the attribute. Does not copy `Name` if `copy_names` is `false`.
2626
27-
passattributes!(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::Bool, idxmap::IndexMap, vis_src::Vector{MOI.VariableIndex}, passattr!::Function=MOI.set)
27+
pass_attributes(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::Bool, idxmap::IndexMap, vis_src::Vector{MOI.VariableIndex}, passattr!::Function=MOI.set)
2828
2929
Pass the variable attributes from the model `src` to the model `dest` using `canpassattr` to check if the attribute can be passed and `passattr!` to pass the attribute. Does not copy `VariableName` if `copy_names` is `false`.
3030
31-
passattributes!(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::Bool, idxmap::IndexMap, cis_src::Vector{MOI.ConstraintIndex{F, S}}, passattr!::Function=MOI.set) where {F, S}
31+
pass_attributes(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::Bool, idxmap::IndexMap, cis_src::Vector{MOI.ConstraintIndex{F, S}}, passattr!::Function=MOI.set) where {F, S}
3232
3333
Pass the constraint attributes of `F`-in-`S` constraints from the model `src` to the model `dest` using `canpassattr` to check if the attribute can be passed and `passattr!` to pass the attribute. Does not copy `ConstraintName` if `copy_names` is `false`.
3434
"""
35-
function passattributes! end
35+
function pass_attributes end
3636

37-
function passattributes!(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::Bool, idxmap::IndexMap, passattr!::Function=MOI.set)
37+
function pass_attributes(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::Bool, idxmap::IndexMap, passattr!::Function=MOI.set)
3838
# Copy model attributes
3939
attrs = MOI.get(src, MOI.ListOfModelAttributesSet())
40-
_passattributes!(dest, src, copy_names, idxmap, attrs, tuple(), tuple(), tuple(), passattr!)
40+
_pass_attributes(dest, src, copy_names, idxmap, attrs, tuple(), tuple(), tuple(), passattr!)
4141
end
42-
function passattributes!(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::Bool, idxmap::IndexMap, vis_src::Vector{VI}, passattr!::Function=MOI.set)
42+
function pass_attributes(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::Bool, idxmap::IndexMap, vis_src::Vector{VI}, passattr!::Function=MOI.set)
4343
# Copy variable attributes
4444
attrs = MOI.get(src, MOI.ListOfVariableAttributesSet())
4545
vis_dest = map(vi -> idxmap[vi], vis_src)
46-
_passattributes!(dest, src, copy_names, idxmap, attrs, (VI,), (vis_src,), (vis_dest,), passattr!)
46+
_pass_attributes(dest, src, copy_names, idxmap, attrs, (VI,), (vis_src,), (vis_dest,), passattr!)
4747
end
48-
function passattributes!(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::Bool, idxmap::IndexMap, cis_src::Vector{CI{F, S}}, passattr!::Function=MOI.set) where {F, S}
48+
function pass_attributes(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::Bool, idxmap::IndexMap, cis_src::Vector{CI{F, S}}, passattr!::Function=MOI.set) where {F, S}
4949
# Copy constraint attributes
5050
attrs = MOI.get(src, MOI.ListOfConstraintAttributesSet{F, S}())
5151
cis_dest = map(ci -> idxmap[ci], cis_src)
52-
_passattributes!(dest, src, copy_names, idxmap, attrs, (CI{F, S},), (cis_src,), (cis_dest,), passattr!)
52+
_pass_attributes(dest, src, copy_names, idxmap, attrs, (CI{F, S},), (cis_src,), (cis_dest,), passattr!)
5353
end
5454

55-
function _passattributes!(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::Bool, idxmap::IndexMap, attrs, canargs, getargs, setargs, passattr!::Function=MOI.set)
55+
function _pass_attributes(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::Bool, idxmap::IndexMap, attrs, canargs, getargs, setargs, passattr!::Function=MOI.set)
5656
for attr in attrs
5757
if (copy_names || !(attr isa MOI.Name || attr isa MOI.VariableName || attr isa MOI.ConstraintName))
5858
passattr!(dest, attr, setargs..., attribute_value_map(idxmap, MOI.get(src, attr, getargs...)))
@@ -76,7 +76,7 @@ function copyconstraints!(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::B
7676
idxmap.conmap[ci_src] = ci_dest
7777
end
7878

79-
passattributes!(dest, src, copy_names, idxmap, cis_src)
79+
pass_attributes(dest, src, copy_names, idxmap, cis_src)
8080
end
8181

8282
attribute_value_map(idxmap, f::MOI.AbstractFunction) = mapvariables(idxmap, f)
@@ -97,10 +97,10 @@ function default_copy_to(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::Bo
9797
end
9898

9999
# Copy variable attributes
100-
passattributes!(dest, src, copy_names, idxmap, vis_src)
100+
pass_attributes(dest, src, copy_names, idxmap, vis_src)
101101

102102
# Copy model attributes
103-
passattributes!(dest, src, copy_names, idxmap)
103+
pass_attributes(dest, src, copy_names, idxmap)
104104

105105
# Copy constraints
106106
for (F, S) in MOI.get(src, MOI.ListOfConstraints())
@@ -121,105 +121,105 @@ end
121121
# To support `MOI.copy_to` using this 2-pass mechanism, implement the allocate-load interface defined below and do:
122122
# MOI.copy_to(dest::ModelType, src::MOI.ModelLike) = MOIU.allocate_load(dest, src)
123123
# In the implementation of the allocate-load interface, it can be assumed that the different functions will the called in the following order:
124-
# 1) `allocatevariables!`
125-
# 2) `allocate!` and `allocateconstraint!`
126-
# 3) `loadvariables!` and `allocateconstraint!`
127-
# 4) `load!` and `loadconstraint!`
128-
# The interface is not meant to be used to create new constraints with `allocateconstraint!` followed by `loadconstraint!` after a solve, it is only meant for being used in this order to implement `MOI.copy_to`.
124+
# 1) `allocate_variables`
125+
# 2) `allocate` and `allocate_constraint`
126+
# 3) `load_variables` and `allocate_constraint`
127+
# 4) `load` and `load_constraint`
128+
# The interface is not meant to be used to create new constraints with `allocate_constraint` followed by `load_constraint` after a solve, it is only meant for being used in this order to implement `MOI.copy_to`.
129129

130130
"""
131131
needs_allocate_load(model::MOI.ModelLike)::Bool
132132
133-
Return a `Bool` indicating whether `model` does not support `add_variables`/`add_constraint`/`set` but supports `allocatevariables!`/`allocateconstraint!`/`allocate!`/`loadvariables!`/`loadconstraint!`/`load!`.
133+
Return a `Bool` indicating whether `model` does not support `add_variables`/`add_constraint`/`set` but supports `allocate_variables`/`allocate_constraint`/`allocate`/`load_variables`/`load_constraint`/`load`.
134134
That is, the allocate-load interface need to be used to copy an model to `model`.
135135
"""
136136
needs_allocate_load(::MOI.ModelLike) = false
137137

138138
"""
139-
allocatevariables!(model::MOI.ModelLike, nvars::Integer)
139+
allocate_variables(model::MOI.ModelLike, nvars::Integer)
140140
141141
Creates `nvars` variables and returns a vector of `nvars` variable indices.
142142
"""
143-
function allocatevariables! end
143+
function allocate_variables end
144144

145145
"""
146-
allocate!(model::ModelLike, attr::ModelLikeAttribute, value)
147-
allocate!(model::ModelLike, attr::AbstractVariableAttribute, v::VariableIndex, value)
148-
allocate!(model::ModelLike, attr::AbstractConstraintAttribute, c::ConstraintIndex, value)
146+
allocate(model::ModelLike, attr::ModelLikeAttribute, value)
147+
allocate(model::ModelLike, attr::AbstractVariableAttribute, v::VariableIndex, value)
148+
allocate(model::ModelLike, attr::AbstractConstraintAttribute, c::ConstraintIndex, value)
149149
150-
Informs `model` that `load!` will be called with the same arguments after `loadvariables!` is called.
150+
Informs `model` that `load` will be called with the same arguments after `load_variables` is called.
151151
"""
152-
function allocate! end
152+
function allocate end
153153

154-
function allocate!(model::MOI.ModelLike, attr::Union{MOI.AbstractVariableAttribute, MOI.AbstractConstraintAttribute}, indices::Vector, values::Vector)
154+
function allocate(model::MOI.ModelLike, attr::Union{MOI.AbstractVariableAttribute, MOI.AbstractConstraintAttribute}, indices::Vector, values::Vector)
155155
for (index, value) in zip(indices, values)
156-
allocate!(model, attr, index, value)
156+
allocate(model, attr, index, value)
157157
end
158158
end
159159

160160
"""
161-
allocateconstraint!(model::MOI.ModelLike, f::MOI.AbstractFunction, s::MOI.AbstractSet)
161+
allocate_constraint(model::MOI.ModelLike, f::MOI.AbstractFunction, s::MOI.AbstractSet)
162162
163-
Returns the index for the constraint to be used in `loadconstraint!` that will be called after `loadvariables!` is called.
163+
Returns the index for the constraint to be used in `load_constraint` that will be called after `load_variables` is called.
164164
"""
165-
function allocateconstraint! end
165+
function allocate_constraint end
166166

167167
"""
168-
loadvariables!(model::MOI.ModelLike, nvars::Integer)
168+
load_variables(model::MOI.ModelLike, nvars::Integer)
169169
170-
Prepares the `model` for `loadobjective!` and `loadconstraint!`.
170+
Prepares the `model` for `loadobjective!` and `load_constraint`.
171171
"""
172-
function loadvariables! end
172+
function load_variables end
173173

174174
"""
175-
load!(model::ModelLike, attr::ModelLikeAttribute, value)
176-
load!(model::ModelLike, attr::AbstractVariableAttribute, v::VariableIndex, value)
177-
load!(model::ModelLike, attr::AbstractConstraintAttribute, c::ConstraintIndex, value)
175+
load(model::ModelLike, attr::ModelLikeAttribute, value)
176+
load(model::ModelLike, attr::AbstractVariableAttribute, v::VariableIndex, value)
177+
load(model::ModelLike, attr::AbstractConstraintAttribute, c::ConstraintIndex, value)
178178
179-
This has the same effect that `set` with the same arguments except that `allocate!` should be called first before `loadvariables!`.
179+
This has the same effect that `set` with the same arguments except that `allocate` should be called first before `load_variables`.
180180
"""
181-
function load! end
181+
function load end
182182

183-
function load!(model::MOI.ModelLike, attr::Union{MOI.AbstractVariableAttribute, MOI.AbstractConstraintAttribute}, indices::Vector, values::Vector)
183+
function load(model::MOI.ModelLike, attr::Union{MOI.AbstractVariableAttribute, MOI.AbstractConstraintAttribute}, indices::Vector, values::Vector)
184184
for (index, value) in zip(indices, values)
185-
load!(model, attr, index, value)
185+
load(model, attr, index, value)
186186
end
187187
end
188188

189189
"""
190-
loadconstraint!(model::MOI.ModelLike, ci::MOI.ConstraintIndex, f::MOI.AbstractFunction, s::MOI.AbstractSet)
190+
load_constraint(model::MOI.ModelLike, ci::MOI.ConstraintIndex, f::MOI.AbstractFunction, s::MOI.AbstractSet)
191191
192192
Sets the constraint function and set for the constraint of index `ci`.
193193
"""
194-
function loadconstraint! end
194+
function load_constraint end
195195

196-
function allocateconstraints!(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::Bool, idxmap::IndexMap, ::Type{F}, ::Type{S}) where {F<:MOI.AbstractFunction, S<:MOI.AbstractSet}
196+
function allocate_constraints(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::Bool, idxmap::IndexMap, ::Type{F}, ::Type{S}) where {F<:MOI.AbstractFunction, S<:MOI.AbstractSet}
197197
# Allocate constraints
198198
cis_src = MOI.get(src, MOI.ListOfConstraintIndices{F, S}())
199199

200200
for ci_src in cis_src
201201
f_src = MOI.get(src, MOI.ConstraintFunction(), ci_src)
202202
s = MOI.get(src, MOI.ConstraintSet(), ci_src)
203203
f_dest = mapvariables(idxmap, f_src)
204-
ci_dest = allocateconstraint!(dest, f_dest, s)
204+
ci_dest = allocate_constraint(dest, f_dest, s)
205205
idxmap.conmap[ci_src] = ci_dest
206206
end
207207

208-
return passattributes!(dest, src, copy_names, idxmap, cis_src, allocate!)
208+
return pass_attributes(dest, src, copy_names, idxmap, cis_src, allocate)
209209
end
210210

211-
function loadconstraints!(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::Bool, idxmap::IndexMap, ::Type{F}, ::Type{S}) where {F<:MOI.AbstractFunction, S<:MOI.AbstractSet}
211+
function load_constraints(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::Bool, idxmap::IndexMap, ::Type{F}, ::Type{S}) where {F<:MOI.AbstractFunction, S<:MOI.AbstractSet}
212212
# Load constraints
213213
cis_src = MOI.get(src, MOI.ListOfConstraintIndices{F, S}())
214214
for ci_src in cis_src
215215
ci_dest = idxmap[ci_src]
216216
f_src = MOI.get(src, MOI.ConstraintFunction(), ci_src)
217217
f_dest = mapvariables(idxmap, f_src)
218218
s = MOI.get(src, MOI.ConstraintSet(), ci_src)
219-
loadconstraint!(dest, ci_dest, f_dest, s)
219+
load_constraint(dest, ci_dest, f_dest, s)
220220
end
221221

222-
return passattributes!(dest, src, copy_names, idxmap, cis_src, load!)
222+
return pass_attributes(dest, src, copy_names, idxmap, cis_src, load)
223223
end
224224

225225
"""
@@ -235,36 +235,36 @@ function allocate_load(dest::MOI.ModelLike, src::MOI.ModelLike, copy_names::Bool
235235
# Allocate variables
236236
nvars = MOI.get(src, MOI.NumberOfVariables())
237237
vis_src = MOI.get(src, MOI.ListOfVariableIndices())
238-
vis_dest = allocatevariables!(dest, nvars)
238+
vis_dest = allocate_variables(dest, nvars)
239239
for (var_src, var_dest) in zip(vis_src, vis_dest)
240240
idxmap.varmap[var_src] = var_dest
241241
end
242242

243243
# Allocate variable attributes
244-
passattributes!(dest, src, copy_names, idxmap, vis_src, allocate!)
244+
pass_attributes(dest, src, copy_names, idxmap, vis_src, allocate)
245245

246246
# Allocate model attributes
247-
passattributes!(dest, src, copy_names, idxmap, allocate!)
247+
pass_attributes(dest, src, copy_names, idxmap, allocate)
248248

249249
# Allocate constraints
250250
for (F, S) in MOI.get(src, MOI.ListOfConstraints())
251251
# do the rest in copyconstraints! which is type stable
252-
allocateconstraints!(dest, src, copy_names, idxmap, F, S)
252+
allocate_constraints(dest, src, copy_names, idxmap, F, S)
253253
end
254254

255255
# Load variables
256-
loadvariables!(dest, nvars)
256+
load_variables(dest, nvars)
257257

258258
# Load variable attributes
259-
passattributes!(dest, src, copy_names, idxmap, vis_src, load!)
259+
pass_attributes(dest, src, copy_names, idxmap, vis_src, load)
260260

261261
# Load model attributes
262-
passattributes!(dest, src, copy_names, idxmap, load!)
262+
pass_attributes(dest, src, copy_names, idxmap, load)
263263

264264
# Copy constraints
265265
for (F, S) in MOI.get(src, MOI.ListOfConstraints())
266266
# do the rest in copyconstraints! which is type stable
267-
loadconstraints!(dest, src, copy_names, idxmap, F, S)
267+
load_constraints(dest, src, copy_names, idxmap, F, S)
268268
end
269269

270270
return idxmap

‎src/Utilities/mockoptimizer.jl

Lines changed: 11 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -280,21 +280,17 @@ end
280280
# Allocate-Load Interface
281281
needs_allocate_load(mock::MockOptimizer) = mock.needs_allocate_load || needs_allocate_load(mock.inner_model)
282282

283-
allocatevariables!(mock::MockOptimizer, nvars) = allocatevariables!(mock.inner_model, nvars)
284-
allocate!(mock::MockOptimizer, attr::MOI.AnyAttribute, value) = allocate!(mock.inner_model, attr, value)
285-
allocate!(mock::MockOptimizer, attr::MOI.ObjectiveFunction, value) = allocate!(mock.inner_model, attr, xor_variables(value))
286-
allocate!(mock::MockOptimizer, attr::MOI.AnyAttribute, idx::MOI.Index, value) = allocate!(mock.inner_model, attr, xor_index(idx), value)
287-
canallocate(mock::MockOptimizer, attr::MOI.AnyAttribute) = canallocate(mock.inner_model, attr)
288-
canallocate(mock::MockOptimizer, attr::MOI.AnyAttribute, IdxT::Type{<:MOI.Index}) = canallocate(mock.inner_model, attr, IdxT)
289-
allocateconstraint!(mock::MockOptimizer, f::MOI.AbstractFunction, s::MOI.AbstractSet) = xor_index(allocateconstraint!(mock.inner_model, xor_variables(f), s))
290-
291-
loadvariables!(mock::MockOptimizer, nvars) = loadvariables!(mock.inner_model, nvars)
292-
load!(mock::MockOptimizer, attr::MOI.AnyAttribute, value) = load!(mock.inner_model, attr, value)
293-
load!(mock::MockOptimizer, attr::MOI.ObjectiveFunction, value) = load!(mock.inner_model, attr, xor_variables(value))
294-
load!(mock::MockOptimizer, attr::MOI.AnyAttribute, idx::MOI.Index, value) = load!(mock.inner_model, attr, xor_index(idx), value)
295-
canload(mock::MockOptimizer, attr::MOI.AnyAttribute) = canload(mock.inner_model, attr)
296-
canload(mock::MockOptimizer, attr::MOI.AnyAttribute, IdxT::Type{<:MOI.Index}) = canload(mock.inner_model, attr, IdxT)
297-
loadconstraint!(mock::MockOptimizer, ci::CI, f::MOI.AbstractFunction, s::MOI.AbstractSet) = loadconstraint!(mock.inner_model, xor_index(ci), xor_variables(f), s)
283+
allocate_variables(mock::MockOptimizer, nvars) = allocate_variables(mock.inner_model, nvars)
284+
allocate(mock::MockOptimizer, attr::MOI.AnyAttribute, value) = allocate(mock.inner_model, attr, value)
285+
allocate(mock::MockOptimizer, attr::MOI.ObjectiveFunction, value) = allocate(mock.inner_model, attr, xor_variables(value))
286+
allocate(mock::MockOptimizer, attr::MOI.AnyAttribute, idx::MOI.Index, value) = allocate(mock.inner_model, attr, xor_index(idx), value)
287+
allocate_constraint(mock::MockOptimizer, f::MOI.AbstractFunction, s::MOI.AbstractSet) = xor_index(allocate_constraint(mock.inner_model, xor_variables(f), s))
288+
289+
load_variables(mock::MockOptimizer, nvars) = load_variables(mock.inner_model, nvars)
290+
load(mock::MockOptimizer, attr::MOI.AnyAttribute, value) = load(mock.inner_model, attr, value)
291+
load(mock::MockOptimizer, attr::MOI.ObjectiveFunction, value) = load(mock.inner_model, attr, xor_variables(value))
292+
load(mock::MockOptimizer, attr::MOI.AnyAttribute, idx::MOI.Index, value) = load(mock.inner_model, attr, xor_index(idx), value)
293+
load_constraint(mock::MockOptimizer, ci::CI, f::MOI.AbstractFunction, s::MOI.AbstractSet) = load_constraint(mock.inner_model, xor_index(ci), xor_variables(f), s)
298294

299295
"""
300296
set_mock_optimize!(mock::MockOptimizer, opt::Function...)

‎src/Utilities/model.jl

Lines changed: 19 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -333,23 +333,29 @@ function MOI.isempty(model::AbstractModel)
333333
iszero(model.nextvariableid) && iszero(model.nextconstraintid)
334334
end
335335

336-
MOI.copy_to(dest::AbstractModel, src::MOI.ModelLike; copy_names=true) = default_copy_to(dest, src, copy_names)
336+
function MOI.copy_to(dest::AbstractModel, src::MOI.ModelLike; copy_names=true)
337+
return default_copy_to(dest, src, copy_names)
338+
end
337339

338340
# Allocate-Load Interface
339-
# Even if the model does not need it and use default_copy_to, it could be used by a layer that needs it
341+
# Even if the model does not need it and use default_copy_to, it could be used
342+
# by a layer that needs it
340343
needs_allocate_load(model::AbstractModel) = false
341344

342-
allocatevariables!(model::AbstractModel, nvars) = MOI.add_variables(model, nvars)
343-
allocate!(model::AbstractModel, attr...) = MOI.set(model, attr...)
344-
canallocate(model::AbstractModel, attr::MOI.AnyAttribute) = MOI.supports(model, attr)
345-
canallocate(model::AbstractModel, attr::MOI.AnyAttribute, IndexType::Type{<:MOI.Index}) = MOI.supports(model, attr, IndexType)
346-
allocateconstraint!(model::AbstractModel, f::MOI.AbstractFunction, s::MOI.AbstractSet) = MOI.add_constraint(model, f, s)
347-
348-
function loadvariables!(::AbstractModel, nvars) end
349-
function load!(::AbstractModel, attr...) end
350-
canload(model::AbstractModel, attr::MOI.AnyAttribute) = MOI.supports(model, attr)
351-
canload(model::AbstractModel, attr::MOI.AnyAttribute, IndexType::Type{<:MOI.Index}) = MOI.supports(model, attr, IndexType)
352-
function loadconstraint!(::AbstractModel, ::CI, ::MOI.AbstractFunction, ::MOI.AbstractSet) end
345+
function allocate_variables(model::AbstractModel, nvars)
346+
return MOI.add_variables(model, nvars)
347+
end
348+
allocate(model::AbstractModel, attr...) = MOI.set(model, attr...)
349+
function allocate_constraint(model::AbstractModel, f::MOI.AbstractFunction,
350+
s::MOI.AbstractSet)
351+
return MOI.add_constraint(model, f, s)
352+
end
353+
354+
function load_variables(::AbstractModel, nvars) end
355+
function load(::AbstractModel, attr...) end
356+
function load_constraint(::AbstractModel, ::CI, ::MOI.AbstractFunction,
357+
::MOI.AbstractSet)
358+
end
353359

354360
# Can be used to access constraints of a model
355361
"""

0 commit comments

Comments
 (0)