From cbe059ba1efcb7d13eb038628238307bf9f01a7d Mon Sep 17 00:00:00 2001 From: odow Date: Thu, 12 Aug 2021 11:39:32 +1200 Subject: [PATCH 1/2] [Utilities] Rename variable and objective containers --- docs/src/submodules/Bridges/overview.md | 28 ++++---- docs/src/submodules/FileFormats/overview.md | 8 +-- docs/src/submodules/Utilities/overview.md | 50 ++++++------- src/Utilities/Utilities.jl | 4 +- src/Utilities/model.jl | 12 ++-- ...on_container.jl => objective_container.jl} | 36 +++++----- ...ector_bounds.jl => variables_container.jl} | 51 ++++++------- test/Utilities/copy.jl | 4 +- test/Utilities/matrix_of_constraints.jl | 20 +++--- test/Utilities/model.jl | 8 +-- .../Utilities/objective_function_container.jl | 22 +++--- test/Utilities/vector_bounds.jl | 71 +++++++------------ 12 files changed, 149 insertions(+), 165 deletions(-) rename src/Utilities/{objective_function_container.jl => objective_container.jl} (82%) rename src/Utilities/{vector_bounds.jl => variables_container.jl} (87%) diff --git a/docs/src/submodules/Bridges/overview.md b/docs/src/submodules/Bridges/overview.md index 6c4467ecb4..d4816c8117 100644 --- a/docs/src/submodules/Bridges/overview.md +++ b/docs/src/submodules/Bridges/overview.md @@ -38,7 +38,7 @@ any optimizer. Some bridges also implement constraint modifications and constraint primal and dual translations. Several bridges can be used in combination to transform a single constraint -into a form that the solver may understand. Choosing the bridges to use +into a form that the solver may understand. Choosing the bridges to use takes the form of finding a shortest path in the hypergraph of bridges. The methodology is detailed in [the MOI paper](https://arxiv.org/abs/2002.03447). @@ -52,14 +52,14 @@ There are three types of bridges in MathOptInterface: ### Constraint bridges Constraint bridges convert constraints formulated by the user into an equivalent -form supported by the solver. Constraint bridges are subtypes of +form supported by the solver. Constraint bridges are subtypes of [`Bridges.Constraint.AbstractBridge`](@ref). The equivalent formulation may add constraints (and possibly also variables) in the underlying model. In particular, constraint bridges can focus on rewriting the function of a -constraint, and do not change the set. Function bridges are subtypes of +constraint, and do not change the set. Function bridges are subtypes of [`Bridges.Constraint.AbstractFunctionConversionBridge`](@ref). Read the [list of implemented constraint bridges](@ref constraint_bridges_ref) @@ -72,7 +72,7 @@ Function bridges are [`Bridges.Constraint.ScalarFunctionizeBridge`](@ref) and Variable bridges convert variables added by the user, either free with [`add_variable`](@ref)/[`add_variables`](@ref), or constrained with [`add_constrained_variable`](@ref)/[`add_constrained_variables`](@ref), -into an equivalent form supported by the solver. Variable bridges are +into an equivalent form supported by the solver. Variable bridges are subtypes of [`Bridges.Variable.AbstractBridge`](@ref). The equivalent formulation may add constraints (and possibly also variables) in @@ -84,7 +84,7 @@ more details on the types of transformations that are available. ### Objective bridges Objective bridges convert the [`ObjectiveFunction`](@ref) set by the user into -an equivalent form supported by the solver. Objective bridges are +an equivalent form supported by the solver. Objective bridges are subtypes of [`Bridges.Objective.AbstractBridge`](@ref). The equivalent formulation may add constraints (and possibly also variables) in @@ -104,14 +104,14 @@ in a [`Bridges.full_bridge_optimizer`](@ref). ```jldoctest julia> inner_optimizer = MOI.Utilities.Model{Float64}() -MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}} +MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}} julia> optimizer = MOI.Bridges.full_bridge_optimizer(inner_optimizer, Float64) -MOIB.LazyBridgeOptimizer{MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}}} +MOIB.LazyBridgeOptimizer{MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}}} with 0 variable bridges with 0 constraint bridges with 0 objective bridges -with inner model MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}} +with inner model MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}} ``` That's all you have to do! Use `optimizer` as normal, and bridging will happen @@ -136,12 +136,12 @@ However, this will force the constraint to be bridged, even if the ```jldoctest julia> inner_optimizer = MOI.Utilities.Model{Float64}() -MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}} +MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}} julia> optimizer = MOI.Bridges.Constraint.SplitInterval{Float64}(inner_optimizer) -MOIB.Constraint.SingleBridgeOptimizer{MOIB.Constraint.SplitIntervalBridge{Float64,F,S,LS,US} where US<:MOI.AbstractSet where LS<:MOI.AbstractSet where S<:MOI.AbstractSet where F<:MOI.AbstractFunction,MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}}} +MOIB.Constraint.SingleBridgeOptimizer{MOIB.Constraint.SplitIntervalBridge{Float64,F,S,LS,US} where US<:MOI.AbstractSet where LS<:MOI.AbstractSet where S<:MOI.AbstractSet where F<:MOI.AbstractFunction,MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}}} with 0 constraint bridges -with inner model MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}} +with inner model MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}} julia> x = MOI.add_variable(optimizer) MOI.VariableIndex(1) @@ -168,14 +168,14 @@ manually construct a [`Bridges.LazyBridgeOptimizer`](@ref). First, wrap an inner optimizer: ```jldoctest lazy_bridge_optimizer julia> inner_optimizer = MOI.Utilities.Model{Float64}() -MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}} +MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}} julia> optimizer = MOI.Bridges.LazyBridgeOptimizer(inner_optimizer) -MOIB.LazyBridgeOptimizer{MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}}} +MOIB.LazyBridgeOptimizer{MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}}} with 0 variable bridges with 0 constraint bridges with 0 objective bridges -with inner model MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}} +with inner model MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}} ``` Then use [`Bridges.add_bridge`](@ref) to add individual bridges: diff --git a/docs/src/submodules/FileFormats/overview.md b/docs/src/submodules/FileFormats/overview.md index a138c645f3..7c80715d6a 100644 --- a/docs/src/submodules/FileFormats/overview.md +++ b/docs/src/submodules/FileFormats/overview.md @@ -65,7 +65,7 @@ To write a model `src` to a [MathOptFormat file](https://jump.dev/MathOptFormat/ use: ```jldoctest fileformats julia> src = MOI.Utilities.Model{Float64}() -MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}} +MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}} julia> MOI.add_variable(src) MathOptInterface.VariableIndex(1) @@ -122,7 +122,7 @@ guess the format from the file extension. For example: ```jldoctest fileformats julia> src = MOI.Utilities.Model{Float64}() -MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}} +MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}} julia> dest = MOI.FileFormats.Model(filename = "file.cbf.gz") A Conic Benchmark Format (CBF) model @@ -136,7 +136,7 @@ julia> src_2 = MOI.FileFormats.Model(filename = "file.cbf.gz") A Conic Benchmark Format (CBF) model julia> src = MOI.Utilities.Model{Float64}() -MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}} +MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}} julia> dest = MOI.FileFormats.Model(filename = "file.cbf.gz") A Conic Benchmark Format (CBF) model @@ -180,7 +180,7 @@ In addition to [`write_to_file`](@ref) and [`read_from_file`](@ref), you can read and write directly from `IO` streams using `Base.write` and `Base.read!`: ```jldoctest julia> src = MOI.Utilities.Model{Float64}() -MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}} +MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}} julia> dest = MOI.FileFormats.Model(format = MOI.FileFormats.FORMAT_MPS) A Mathematical Programming System (MPS) model diff --git a/docs/src/submodules/Utilities/overview.md b/docs/src/submodules/Utilities/overview.md index 1a2ed2b04c..36ac7f1d5b 100644 --- a/docs/src/submodules/Utilities/overview.md +++ b/docs/src/submodules/Utilities/overview.md @@ -21,7 +21,7 @@ given the extensibility of MOI, this might not cover all use cases. Create a model as follows: ```jldoctest julia> model = MOI.Utilities.Model{Float64}() -MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}} +MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}} ``` ## Utilities.UniversalFallback @@ -36,8 +36,8 @@ like [`VariablePrimalStart`](@ref), so JuMP uses a combination of Universal fallback and [`Utilities.Model`](@ref) as a generic problem cache: ```jldoctest julia> model = MOI.Utilities.UniversalFallback(MOI.Utilities.Model{Float64}()) -MOIU.UniversalFallback{MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}}} -fallback for MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}} +MOIU.UniversalFallback{MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}}} +fallback for MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}} ``` !!! warning @@ -83,10 +83,10 @@ julia> MOI.Utilities.@model( (MOI.VectorAffineFunction,), # Typed vector functions true, # <:MOI.AbstractOptimizer? ) -MathOptInterface.Utilities.GenericOptimizer{T,MathOptInterface.Utilities.ObjectiveFunctionContainer{T},MathOptInterface.Utilities.SingleVariableConstraints{T},MyNewModelFunctionConstraints{T}} where T +MathOptInterface.Utilities.GenericOptimizer{T,MathOptInterface.Utilities.ObjectiveContainer{T},MathOptInterface.Utilities.VariablesContainer{T},MyNewModelFunctionConstraints{T}} where T julia> model = MyNewModel{Float64}() -MOIU.GenericOptimizer{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MyNewModelFunctionConstraints{Float64}} +MOIU.GenericOptimizer{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MyNewModelFunctionConstraints{Float64}} ``` !!! warning @@ -112,7 +112,7 @@ julia> MOI.Utilities.@model( (MOI.VectorAffineFunction,), # Typed vector functions true, # is_optimizer ) -MathOptInterface.Utilities.GenericOptimizer{T,MathOptInterface.Utilities.ObjectiveFunctionContainer{T},MathOptInterface.Utilities.SingleVariableConstraints{T},MathOptInterface.Utilities.VectorOfConstraints{MathOptInterface.VectorAffineFunction{T},MathOptInterface.Complements}} where T +MathOptInterface.Utilities.GenericOptimizer{T,MathOptInterface.Utilities.ObjectiveContainer{T},MathOptInterface.Utilities.VariablesContainer{T},MathOptInterface.Utilities.VectorOfConstraints{MathOptInterface.VectorAffineFunction{T},MathOptInterface.Complements}} where T ``` However, `PathOptimizer` does not support some `SingleVariable`-in-Set constraints, so we must explicitly define: @@ -152,11 +152,11 @@ julia> model = MOI.Utilities.CachingOptimizer( MOI.Utilities.Model{Float64}(), PathOptimizer{Float64}(), ) -MOIU.CachingOptimizer{MOIU.GenericOptimizer{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.VectorOfConstraints{MOI.VectorAffineFunction{Float64},MOI.Complements}},MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}}} +MOIU.CachingOptimizer{MOIU.GenericOptimizer{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.VectorOfConstraints{MOI.VectorAffineFunction{Float64},MOI.Complements}},MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}}} in state EMPTY_OPTIMIZER in mode AUTOMATIC -with model cache MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}} -with optimizer MOIU.GenericOptimizer{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.VectorOfConstraints{MOI.VectorAffineFunction{Float64},MOI.Complements}} +with model cache MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}} +with optimizer MOIU.GenericOptimizer{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.VectorOfConstraints{MOI.VectorAffineFunction{Float64},MOI.Complements}} ``` A [`Utilities.CachingOptimizer`](@ref) may be in one of three possible states: @@ -176,11 +176,11 @@ Use [`Utilities.attach_optimizer`](@ref) to go from `EMPTY_OPTIMIZER` to julia> MOI.Utilities.attach_optimizer(model) julia> model -MOIU.CachingOptimizer{MOIU.GenericOptimizer{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.VectorOfConstraints{MOI.VectorAffineFunction{Float64},MOI.Complements}},MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}}} +MOIU.CachingOptimizer{MOIU.GenericOptimizer{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.VectorOfConstraints{MOI.VectorAffineFunction{Float64},MOI.Complements}},MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}}} in state ATTACHED_OPTIMIZER in mode AUTOMATIC -with model cache MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}} -with optimizer MOIU.GenericOptimizer{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.VectorOfConstraints{MOI.VectorAffineFunction{Float64},MOI.Complements}} +with model cache MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}} +with optimizer MOIU.GenericOptimizer{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.VectorOfConstraints{MOI.VectorAffineFunction{Float64},MOI.Complements}} ``` !!! info @@ -192,11 +192,11 @@ Use [`Utilities.reset_optimizer`](@ref) to go from `ATTACHED_OPTIMIZER` to julia> MOI.Utilities.reset_optimizer(model) julia> model -MOIU.CachingOptimizer{MOIU.GenericOptimizer{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.VectorOfConstraints{MOI.VectorAffineFunction{Float64},MOI.Complements}},MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}}} +MOIU.CachingOptimizer{MOIU.GenericOptimizer{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.VectorOfConstraints{MOI.VectorAffineFunction{Float64},MOI.Complements}},MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}}} in state EMPTY_OPTIMIZER in mode AUTOMATIC -with model cache MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}} -with optimizer MOIU.GenericOptimizer{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.VectorOfConstraints{MOI.VectorAffineFunction{Float64},MOI.Complements}} +with model cache MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}} +with optimizer MOIU.GenericOptimizer{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.VectorOfConstraints{MOI.VectorAffineFunction{Float64},MOI.Complements}} ``` !!! info @@ -209,10 +209,10 @@ Use [`Utilities.drop_optimizer`](@ref) to go from any state to `NO_OPTIMIZER`: julia> MOI.Utilities.drop_optimizer(model) julia> model -MOIU.CachingOptimizer{MOIU.GenericOptimizer{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.VectorOfConstraints{MOI.VectorAffineFunction{Float64},MOI.Complements}},MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}}} +MOIU.CachingOptimizer{MOIU.GenericOptimizer{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.VectorOfConstraints{MOI.VectorAffineFunction{Float64},MOI.Complements}},MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}}} in state NO_OPTIMIZER in mode AUTOMATIC -with model cache MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}} +with model cache MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}} with optimizer nothing ``` @@ -222,11 +222,11 @@ Pass an empty optimizer to [`Utilities.reset_optimizer`](@ref) to go from julia> MOI.Utilities.reset_optimizer(model, PathOptimizer{Float64}()) julia> model -MOIU.CachingOptimizer{MOIU.GenericOptimizer{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.VectorOfConstraints{MOI.VectorAffineFunction{Float64},MOI.Complements}},MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}}} +MOIU.CachingOptimizer{MOIU.GenericOptimizer{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.VectorOfConstraints{MOI.VectorAffineFunction{Float64},MOI.Complements}},MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}}} in state EMPTY_OPTIMIZER in mode AUTOMATIC -with model cache MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}} -with optimizer MOIU.GenericOptimizer{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.VectorOfConstraints{MOI.VectorAffineFunction{Float64},MOI.Complements}} +with model cache MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}} +with optimizer MOIU.GenericOptimizer{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.VectorOfConstraints{MOI.VectorAffineFunction{Float64},MOI.Complements}} ``` Deciding when to attach and reset the optimizer is tedious, and you will often @@ -256,20 +256,20 @@ julia> model = MOI.Utilities.CachingOptimizer( MOI.Utilities.Model{Float64}(), MOI.Utilities.MANUAL, ) -MOIU.CachingOptimizer{MOI.AbstractOptimizer,MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}}} +MOIU.CachingOptimizer{MOI.AbstractOptimizer,MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}}} in state NO_OPTIMIZER in mode MANUAL -with model cache MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}} +with model cache MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}} with optimizer nothing julia> MOI.Utilities.reset_optimizer(model, PathOptimizer{Float64}()) julia> model -MOIU.CachingOptimizer{MOI.AbstractOptimizer,MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}}} +MOIU.CachingOptimizer{MOI.AbstractOptimizer,MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}}} in state EMPTY_OPTIMIZER in mode MANUAL -with model cache MOIU.GenericModel{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.ModelFunctionConstraints{Float64}} -with optimizer MOIU.GenericOptimizer{Float64,MOIU.ObjectiveFunctionContainer{Float64},MOIU.SingleVariableConstraints{Float64},MOIU.VectorOfConstraints{MOI.VectorAffineFunction{Float64},MOI.Complements}} +with model cache MOIU.GenericModel{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.ModelFunctionConstraints{Float64}} +with optimizer MOIU.GenericOptimizer{Float64,MOIU.ObjectiveContainer{Float64},MOIU.VariablesContainer{Float64},MOIU.VectorOfConstraints{MOI.VectorAffineFunction{Float64},MOI.Complements}} ``` ## Printing diff --git a/src/Utilities/Utilities.jl b/src/Utilities/Utilities.jl index e7e74b241f..e48096d776 100644 --- a/src/Utilities/Utilities.jl +++ b/src/Utilities/Utilities.jl @@ -59,8 +59,8 @@ include("copy.jl") include("results.jl") include("variables.jl") -include("objective_function_container.jl") -include("vector_bounds.jl") +include("objective_container.jl") +include("variables_container.jl") include("vector_of_constraints.jl") include("struct_of_constraints.jl") include("model.jl") diff --git a/src/Utilities/model.jl b/src/Utilities/model.jl index 4d882d4ac7..c06c7df389 100644 --- a/src/Utilities/model.jl +++ b/src/Utilities/model.jl @@ -666,7 +666,7 @@ struct LPModelFunctionConstraints{T} <: MOIU.StructOfConstraints MOIU.VectorOfConstraints{MOI.VectorAffineFunction{T}, MOI.Nonpositives} } end -const LPModel{T} = MOIU.GenericModel{T,MOIU.ObjectiveFunctionContainer{T},MOIU.SingleVariableConstraints{T},LPModelFunctionConstraints{T}} +const LPModel{T} = MOIU.GenericModel{T,MOIU.ObjectiveContainer{T},MOIU.VariablesContainer{T},LPModelFunctionConstraints{T}} ``` The type `LPModel` implements the MathOptInterface API except methods specific to optimizers like `optimize!` or `get` with `VariablePrimal`. @@ -720,15 +720,15 @@ macro model( generic = if is_optimizer :(GenericOptimizer{ $T, - ObjectiveFunctionContainer{$T}, - SingleVariableConstraints{$T}, + ObjectiveContainer{$T}, + VariablesContainer{$T}, $func_typed, }) else :(GenericModel{ $T, - ObjectiveFunctionContainer{$T}, - SingleVariableConstraints{$T}, + ObjectiveContainer{$T}, + VariablesContainer{$T}, $func_typed, }) end @@ -874,7 +874,7 @@ Model # julia> print(MathOptInterface.Utilities.Model) # MathOptInterface.Utilities.Model{T} where T # julia> MathOptInterface.Utilities.Model -# MathOptInterface.Utilities.Model{T} where T (alias for MathOptInterface.Utilities.GenericModel{T, MathOptInterface.Utilities.ObjectiveFunctionContainer{T}, MathOptInterface.Utilities.SingleVariableConstraints{T}, MathOptInterface.Utilities.ModelFunctionConstraints{T}} where T) +# MathOptInterface.Utilities.Model{T} where T (alias for MathOptInterface.Utilities.GenericModel{T, MathOptInterface.Utilities.ObjectiveContainer{T}, MathOptInterface.Utilities.VariablesContainer{T}, MathOptInterface.Utilities.ModelFunctionConstraints{T}} where T) # ``` # As MOI is not doing `using .Utilities` and is not exporting `Model`, the user # still needs to do `MOI.Utilities.Model` unless he does diff --git a/src/Utilities/objective_function_container.jl b/src/Utilities/objective_container.jl similarity index 82% rename from src/Utilities/objective_function_container.jl rename to src/Utilities/objective_container.jl index 763722f6cf..1c518749ec 100644 --- a/src/Utilities/objective_function_container.jl +++ b/src/Utilities/objective_container.jl @@ -1,24 +1,24 @@ """ - ObjectiveFunctionContainer{T} + ObjectiveContainer{T} A helper struct to simplify the handling of objective functions in Utilities.Model. """ -mutable struct ObjectiveFunctionContainer{T} <: MOI.ModelLike +mutable struct ObjectiveContainer{T} <: MOI.ModelLike is_sense_set::Bool sense::MOI.OptimizationSense is_function_set::Bool single_variable::Union{Nothing,MOI.SingleVariable} scalar_affine::Union{Nothing,MOI.ScalarAffineFunction{T}} scalar_quadratic::Union{Nothing,MOI.ScalarQuadraticFunction{T}} - function ObjectiveFunctionContainer{T}() where {T} + function ObjectiveContainer{T}() where {T} o = new{T}() MOI.empty!(o) return o end end -function MOI.empty!(o::ObjectiveFunctionContainer{T}) where {T} +function MOI.empty!(o::ObjectiveContainer{T}) where {T} o.is_sense_set = false o.sense = MOI.FEASIBILITY_SENSE o.is_function_set = false @@ -29,7 +29,7 @@ function MOI.empty!(o::ObjectiveFunctionContainer{T}) where {T} return end -function MOI.is_empty(o::ObjectiveFunctionContainer) +function MOI.is_empty(o::ObjectiveContainer) return !o.is_sense_set && !o.is_function_set end @@ -37,11 +37,11 @@ end ### ObjectiveSense ### -MOI.supports(::ObjectiveFunctionContainer, ::MOI.ObjectiveSense) = true +MOI.supports(::ObjectiveContainer, ::MOI.ObjectiveSense) = true -MOI.get(o::ObjectiveFunctionContainer, ::MOI.ObjectiveSense) = o.sense +MOI.get(o::ObjectiveContainer, ::MOI.ObjectiveSense) = o.sense -function MOI.set(o::ObjectiveFunctionContainer, ::MOI.ObjectiveSense, value) +function MOI.set(o::ObjectiveContainer, ::MOI.ObjectiveSense, value) if value == MOI.FEASIBILITY_SENSE MOI.empty!(o) end @@ -55,7 +55,7 @@ end ### function MOI.get( - o::ObjectiveFunctionContainer{T}, + o::ObjectiveContainer{T}, ::MOI.ObjectiveFunctionType, ) where {T} if o.single_variable !== nothing @@ -72,7 +72,7 @@ end ### function MOI.supports( - ::ObjectiveFunctionContainer{T}, + ::ObjectiveContainer{T}, ::MOI.ObjectiveFunction{ <:Union{ MOI.SingleVariable, @@ -85,7 +85,7 @@ function MOI.supports( end function MOI.get( - o::ObjectiveFunctionContainer{T}, + o::ObjectiveContainer{T}, ::MOI.ObjectiveFunction{F}, ) where {T,F} if o.single_variable !== nothing @@ -98,7 +98,7 @@ function MOI.get( end function MOI.set( - o::ObjectiveFunctionContainer, + o::ObjectiveContainer, ::MOI.ObjectiveFunction{MOI.SingleVariable}, f::MOI.SingleVariable, ) @@ -110,7 +110,7 @@ function MOI.set( end function MOI.set( - o::ObjectiveFunctionContainer{T}, + o::ObjectiveContainer{T}, ::MOI.ObjectiveFunction{MOI.ScalarAffineFunction{T}}, f::MOI.ScalarAffineFunction{T}, ) where {T} @@ -122,7 +122,7 @@ function MOI.set( end function MOI.set( - o::ObjectiveFunctionContainer{T}, + o::ObjectiveContainer{T}, ::MOI.ObjectiveFunction{MOI.ScalarQuadraticFunction{T}}, f::MOI.ScalarQuadraticFunction{T}, ) where {T} @@ -137,7 +137,7 @@ end ### MOI.ListOfModelAttributesSet ### -function MOI.get(o::ObjectiveFunctionContainer, ::MOI.ListOfModelAttributesSet) +function MOI.get(o::ObjectiveContainer, ::MOI.ListOfModelAttributesSet) ret = MOI.AbstractModelAttribute[] if o.is_sense_set push!(ret, MOI.ObjectiveSense()) @@ -154,7 +154,7 @@ end ### function MOI.modify( - o::ObjectiveFunctionContainer, + o::ObjectiveContainer, ::MOI.ObjectiveFunction, change::MOI.AbstractFunctionModification, ) @@ -174,7 +174,7 @@ end ### MOI.delete ### -function MOI.delete(o::ObjectiveFunctionContainer, x::MOI.VariableIndex) +function MOI.delete(o::ObjectiveContainer, x::MOI.VariableIndex) if o.single_variable !== nothing if x == o.single_variable.variable sense = o.sense @@ -192,7 +192,7 @@ function MOI.delete(o::ObjectiveFunctionContainer, x::MOI.VariableIndex) return end -function MOI.delete(o::ObjectiveFunctionContainer, x::Vector{MOI.VariableIndex}) +function MOI.delete(o::ObjectiveContainer, x::Vector{MOI.VariableIndex}) keep = v -> !(v in x) if o.single_variable !== nothing if o.single_variable.variable in x diff --git a/src/Utilities/vector_bounds.jl b/src/Utilities/variables_container.jl similarity index 87% rename from src/Utilities/vector_bounds.jl rename to src/Utilities/variables_container.jl index e6cc5a36b8..b5d652b8dc 100644 --- a/src/Utilities/vector_bounds.jl +++ b/src/Utilities/variables_container.jl @@ -45,7 +45,7 @@ end SUPPORTED_VARIABLE_SCALAR_SETS{T} The union of scalar sets for `SingleVariable` constraints supported by -`Utilities.Hyperrectangle` and `Utilities.SingleVariableConstraints`. +`Utilities.Hyperrectangle` and `Utilities.VariablesContainer`. """ const SUPPORTED_VARIABLE_SCALAR_SETS{T} = Union{ MOI.EqualTo{T}, @@ -154,62 +154,63 @@ _no_upper_bound(::Type{T}) where {T} = zero(T) _no_upper_bound(::Type{T}) where {T<:AbstractFloat} = typemax(T) ### -### SingleVariableConstraints +### VariablesContainer ### ### For use in MOI.Utilities.Model ### """ - struct SingleVariableConstraints{T} <: AbstractVectorBounds + struct VariablesContainer{T} <: AbstractVectorBounds set_mask::Vector{UInt16} lower::Vector{T} upper::Vector{T} end -A struct for storing SingleVariable-related constraints. Used in `MOI.Model`. +A struct for storing variables and SingleVariable-related constraints. Used in +`MOI.Utilities.Model` by default. """ -mutable struct SingleVariableConstraints{T} <: AbstractVectorBounds +mutable struct VariablesContainer{T} <: AbstractVectorBounds set_mask::Vector{UInt16} lower::Vector{T} upper::Vector{T} end -function SingleVariableConstraints{T}() where {T} - return SingleVariableConstraints{T}(UInt16[], T[], T[]) +function VariablesContainer{T}() where {T} + return VariablesContainer{T}(UInt16[], T[], T[]) end -function MOI.throw_if_not_valid(b::SingleVariableConstraints, index) +function MOI.throw_if_not_valid(b::VariablesContainer, index) if !MOI.is_valid(b, index) throw(MOI.InvalidIndex(index)) end end -function Base.:(==)(a::SingleVariableConstraints, b::SingleVariableConstraints) +function Base.:(==)(a::VariablesContainer, b::VariablesContainer) return a.set_mask == b.set_mask && a.lower == b.lower && a.upper == b.upper end -function MOI.empty!(b::SingleVariableConstraints) +function MOI.empty!(b::VariablesContainer) empty!(b.set_mask) empty!(b.lower) empty!(b.upper) return b end -function MOI.is_empty(b::SingleVariableConstraints) +function MOI.is_empty(b::VariablesContainer) if length(b.set_mask) == 0 return true end return all(isequal(_DELETED_VARIABLE), b.set_mask) end -function Base.resize!(b::SingleVariableConstraints, n) +function Base.resize!(b::VariablesContainer, n) resize!(b.set_mask, n) resize!(b.lower, n) resize!(b.upper, n) return end -function MOI.add_variable(b::SingleVariableConstraints{T}) where {T} +function MOI.add_variable(b::VariablesContainer{T}) where {T} push!(b.set_mask, 0x0000) push!(b.lower, _no_lower_bound(T)) push!(b.upper, _no_upper_bound(T)) @@ -217,19 +218,19 @@ function MOI.add_variable(b::SingleVariableConstraints{T}) where {T} return x end -function MOI.get(b::SingleVariableConstraints, ::MOI.ListOfVariableIndices) +function MOI.get(b::VariablesContainer, ::MOI.ListOfVariableIndices) return MOI.VariableIndex[ MOI.VariableIndex(i) for i in 1:length(b.set_mask) if b.set_mask[i] != _DELETED_VARIABLE ] end -function MOI.is_valid(b::SingleVariableConstraints, x::MOI.VariableIndex) +function MOI.is_valid(b::VariablesContainer, x::MOI.VariableIndex) mask = get(b.set_mask, x.value, _DELETED_VARIABLE) return mask != _DELETED_VARIABLE end -function MOI.get(b::SingleVariableConstraints, ::MOI.NumberOfVariables)::Int64 +function MOI.get(b::VariablesContainer, ::MOI.NumberOfVariables)::Int64 if length(b.set_mask) == 0 return 0 end @@ -237,7 +238,7 @@ function MOI.get(b::SingleVariableConstraints, ::MOI.NumberOfVariables)::Int64 end function MOI.add_constraint( - b::SingleVariableConstraints{T}, + b::VariablesContainer{T}, f::MOI.SingleVariable, set::S, ) where {T,S} @@ -256,7 +257,7 @@ function MOI.add_constraint( end function MOI.delete( - b::SingleVariableConstraints{T}, + b::VariablesContainer{T}, ci::MOI.ConstraintIndex{MOI.SingleVariable,S}, ) where {T,S} MOI.throw_if_not_valid(b, ci) @@ -271,14 +272,14 @@ function MOI.delete( return end -function MOI.delete(b::SingleVariableConstraints, x::MOI.VariableIndex) +function MOI.delete(b::VariablesContainer, x::MOI.VariableIndex) MOI.throw_if_not_valid(b, x) b.set_mask[x.value] = _DELETED_VARIABLE return end function MOI.is_valid( - b::SingleVariableConstraints, + b::VariablesContainer, ci::MOI.ConstraintIndex{MOI.SingleVariable,S}, ) where {S} if !(1 <= ci.value <= length(b.set_mask)) @@ -288,7 +289,7 @@ function MOI.is_valid( end function MOI.set( - b::SingleVariableConstraints, + b::VariablesContainer, ::MOI.ConstraintSet, ci::MOI.ConstraintIndex{MOI.SingleVariable,S}, set::S, @@ -304,7 +305,7 @@ function MOI.set( end function MOI.get( - b::SingleVariableConstraints, + b::VariablesContainer, ::MOI.NumberOfConstraints{MOI.SingleVariable,S}, )::Int64 where {S} flag = _single_variable_flag(S) @@ -313,7 +314,7 @@ end function _add_constraint_type( list, - b::SingleVariableConstraints, + b::VariablesContainer, S::Type{<:MOI.AbstractScalarSet}, ) flag = _single_variable_flag(S)::UInt16 @@ -324,7 +325,7 @@ function _add_constraint_type( end function MOI.get( - b::SingleVariableConstraints{T}, + b::VariablesContainer{T}, ::MOI.ListOfConstraintTypesPresent, ) where {T} list = Tuple{Type,Type}[] @@ -340,7 +341,7 @@ function MOI.get( end function MOI.get( - b::SingleVariableConstraints, + b::VariablesContainer, ::MOI.ListOfConstraintIndices{MOI.SingleVariable,S}, ) where {S} list = MOI.ConstraintIndex{MOI.SingleVariable,S}[] diff --git a/test/Utilities/copy.jl b/test/Utilities/copy.jl index 28e976aa6b..a32b50a8dd 100644 --- a/test/Utilities/copy.jl +++ b/test/Utilities/copy.jl @@ -773,8 +773,8 @@ function _test_copy_of_constraints_passed_as_copy_accross_layers( MOIU.UniversalFallback( MOIU.GenericOptimizer{ T, - MOI.Utilities.ObjectiveFunctionContainer{T}, - MOI.Utilities.SingleVariableConstraints{T}, + MOI.Utilities.ObjectiveContainer{T}, + MOI.Utilities.VariablesContainer{T}, OnlyCopyConstraints{F,S}, }(), ), diff --git a/test/Utilities/matrix_of_constraints.jl b/test/Utilities/matrix_of_constraints.jl index 0a6339fe83..e7dfca9ee8 100644 --- a/test/Utilities/matrix_of_constraints.jl +++ b/test/Utilities/matrix_of_constraints.jl @@ -29,8 +29,8 @@ MOI.Utilities.@product_of_sets( function _new_ScalarSets() return MOI.Utilities.GenericOptimizer{ Float64, - MOI.Utilities.ObjectiveFunctionContainer{Float64}, - MOI.Utilities.SingleVariableConstraints{Float64}, + MOI.Utilities.ObjectiveContainer{Float64}, + MOI.Utilities.VariablesContainer{Float64}, MOI.Utilities.MatrixOfConstraints{ Float64, MOI.Utilities.MutableSparseMatrixCSC{ @@ -54,8 +54,8 @@ MOI.Utilities.@product_of_sets( function _new_VectorSets() return MOI.Utilities.GenericOptimizer{ Int, - MOI.Utilities.ObjectiveFunctionContainer{Int}, - MOI.Utilities.SingleVariableConstraints{Int}, + MOI.Utilities.ObjectiveContainer{Int}, + MOI.Utilities.VariablesContainer{Int}, MOI.Utilities.MatrixOfConstraints{ Int, MOI.Utilities.MutableSparseMatrixCSC{ @@ -281,8 +281,8 @@ end function test_ScalarSets() optimizer = MOI.Utilities.GenericOptimizer{ Float64, - MOI.Utilities.ObjectiveFunctionContainer{Float64}, - MOI.Utilities.SingleVariableConstraints{Float64}, + MOI.Utilities.ObjectiveContainer{Float64}, + MOI.Utilities.VariablesContainer{Float64}, MOI.Utilities.MatrixOfConstraints{ Float64, MOI.Utilities.MutableSparseMatrixCSC{ @@ -311,8 +311,8 @@ end function test_modify() model = MOI.Utilities.GenericOptimizer{ Int, - MOI.Utilities.ObjectiveFunctionContainer{Int}, - MOI.Utilities.SingleVariableConstraints{Int}, + MOI.Utilities.ObjectiveContainer{Int}, + MOI.Utilities.VariablesContainer{Int}, MOI.Utilities.MatrixOfConstraints{ Int, MOI.Utilities.MutableSparseMatrixCSC{ @@ -351,8 +351,8 @@ function test_multicone() Indexing = MOI.Utilities.OneBasedIndexing model = MOI.Utilities.GenericOptimizer{ T, - MOI.Utilities.ObjectiveFunctionContainer{T}, - MOI.Utilities.SingleVariableConstraints{T}, + MOI.Utilities.ObjectiveContainer{T}, + MOI.Utilities.VariablesContainer{T}, ZerosOrNot{T}{ MOI.Utilities.MatrixOfConstraints{ T, diff --git a/test/Utilities/model.jl b/test/Utilities/model.jl index 4c3718d2ad..c8197294c1 100644 --- a/test/Utilities/model.jl +++ b/test/Utilities/model.jl @@ -101,14 +101,14 @@ function test_TestExternalModel_fields() @test !isdefined(TestExternalModel, :ExternalOptimizerFunctionConstraints) @test TestExternalModel.ExternalModel{Int} == MOI.Utilities.GenericModel{ Int, - MOI.Utilities.ObjectiveFunctionContainer{Int}, - MOI.Utilities.SingleVariableConstraints{Int}, + MOI.Utilities.ObjectiveContainer{Int}, + MOI.Utilities.VariablesContainer{Int}, TestExternalModel.ExternalModelFunctionConstraints{Int}, } model = MOI.Utilities.GenericOptimizer{ Int, - MOI.Utilities.ObjectiveFunctionContainer{Int}, - MOI.Utilities.SingleVariableConstraints{Int}, + MOI.Utilities.ObjectiveContainer{Int}, + MOI.Utilities.VariablesContainer{Int}, TestExternalModel.ExternalOptimizerScalarConstraints{ Int, MOI.Utilities.VectorOfConstraints{ diff --git a/test/Utilities/objective_function_container.jl b/test/Utilities/objective_function_container.jl index e0df88f4c9..09df4fc620 100644 --- a/test/Utilities/objective_function_container.jl +++ b/test/Utilities/objective_function_container.jl @@ -1,4 +1,4 @@ -module TestObjectiveFunctionContainer +module TestObjectiveContainer using Test @@ -18,7 +18,7 @@ function runtests() end function test_ObjectiveSense() - o = MOI.Utilities.ObjectiveFunctionContainer{Float16}() + o = MOI.Utilities.ObjectiveContainer{Float16}() @test MOI.get(o, MOI.ListOfModelAttributesSet()) == [] @test MOI.supports(o, MOI.ObjectiveSense()) for val in (MOI.MIN_SENSE, MOI.MAX_SENSE, MOI.FEASIBILITY_SENSE) @@ -29,7 +29,7 @@ function test_ObjectiveSense() end function test_FEASIBILITY_SENSE_clears_objective() - o = MOI.Utilities.ObjectiveFunctionContainer{Float16}() + o = MOI.Utilities.ObjectiveContainer{Float16}() x = MOI.VariableIndex(1234) f = MOI.SingleVariable(x) MOI.set(o, MOI.ObjectiveFunction{MOI.SingleVariable}(), f) @@ -41,7 +41,7 @@ function test_FEASIBILITY_SENSE_clears_objective() end function _test_basic_objective(F, T) - o = MOI.Utilities.ObjectiveFunctionContainer{T}() + o = MOI.Utilities.ObjectiveContainer{T}() @test MOI.is_empty(o) @test MOI.supports(o, MOI.ObjectiveFunction{F}()) x = MOI.VariableIndex(1234) @@ -64,7 +64,7 @@ function test_basic_objective() end function test_delete_SingleVariable() - o = MOI.Utilities.ObjectiveFunctionContainer{Float16}() + o = MOI.Utilities.ObjectiveContainer{Float16}() x = MOI.VariableIndex(1234) f = MOI.SingleVariable(x) MOI.set(o, MOI.ObjectiveFunction{MOI.SingleVariable}(), f) @@ -74,7 +74,7 @@ function test_delete_SingleVariable() end function test_delete_ScalarAffineFunction() - o = MOI.Utilities.ObjectiveFunctionContainer{Float16}() + o = MOI.Utilities.ObjectiveContainer{Float16}() x = MOI.VariableIndex(1234) f = convert(MOI.ScalarAffineFunction{Float16}, MOI.SingleVariable(x)) MOI.set(o, MOI.ObjectiveFunction{typeof(f)}(), f) @@ -85,7 +85,7 @@ function test_delete_ScalarAffineFunction() end function test_delete_ScalarQuadraticFunction() - o = MOI.Utilities.ObjectiveFunctionContainer{Float16}() + o = MOI.Utilities.ObjectiveContainer{Float16}() x = MOI.VariableIndex(1234) f = convert(MOI.ScalarQuadraticFunction{Float16}, MOI.SingleVariable(x)) MOI.set(o, MOI.ObjectiveFunction{typeof(f)}(), f) @@ -96,7 +96,7 @@ function test_delete_ScalarQuadraticFunction() end function test_delete_SingleVariable_plural() - o = MOI.Utilities.ObjectiveFunctionContainer{Float16}() + o = MOI.Utilities.ObjectiveContainer{Float16}() x = MOI.VariableIndex(1234) f = MOI.SingleVariable(x) MOI.set(o, MOI.ObjectiveFunction{MOI.SingleVariable}(), f) @@ -106,7 +106,7 @@ function test_delete_SingleVariable_plural() end function test_delete_ScalarAffineFunction_plural() - o = MOI.Utilities.ObjectiveFunctionContainer{Float16}() + o = MOI.Utilities.ObjectiveContainer{Float16}() x = MOI.VariableIndex(1234) f = convert(MOI.ScalarAffineFunction{Float16}, MOI.SingleVariable(x)) MOI.set(o, MOI.ObjectiveFunction{typeof(f)}(), f) @@ -117,7 +117,7 @@ function test_delete_ScalarAffineFunction_plural() end function test_delete_ScalarQuadraticFunction_plural() - o = MOI.Utilities.ObjectiveFunctionContainer{Float16}() + o = MOI.Utilities.ObjectiveContainer{Float16}() x = MOI.VariableIndex(1234) f = convert(MOI.ScalarQuadraticFunction{Float16}, MOI.SingleVariable(x)) MOI.set(o, MOI.ObjectiveFunction{typeof(f)}(), f) @@ -129,4 +129,4 @@ end end # module -TestObjectiveFunctionContainer.runtests() +TestObjectiveContainer.runtests() diff --git a/test/Utilities/vector_bounds.jl b/test/Utilities/vector_bounds.jl index ceea967305..8ff9887487 100644 --- a/test/Utilities/vector_bounds.jl +++ b/test/Utilities/vector_bounds.jl @@ -16,22 +16,14 @@ function runtests() end function test_empty() - a = MOI.Utilities.SingleVariableConstraints( - [0x0000, 0x0000], - [1, 2], - [3, 4], - ) + a = MOI.Utilities.VariablesContainer([0x0000, 0x0000], [1, 2], [3, 4]) MOI.empty!(a) @test MOI.is_empty(a) return end function test_resize() - a = MOI.Utilities.SingleVariableConstraints( - [0x0000, 0x0000], - [1, 2], - [3, 4], - ) + a = MOI.Utilities.VariablesContainer([0x0000, 0x0000], [1, 2], [3, 4]) @test length(a.set_mask) == 2 @test length(a.lower) == 2 @test length(a.upper) == 2 @@ -43,16 +35,13 @@ function test_resize() end function test_add_variable() - a = MOI.Utilities.SingleVariableConstraints{Int}() + a = MOI.Utilities.VariablesContainer{Int}() MOI.add_variable(a) - @test a == MOI.Utilities.SingleVariableConstraints{Int}([0x0000], [0], [0]) - a = MOI.Utilities.SingleVariableConstraints{Float64}() + @test a == MOI.Utilities.VariablesContainer{Int}([0x0000], [0], [0]) + a = MOI.Utilities.VariablesContainer{Float64}() MOI.add_variable(a) - @test a == MOI.Utilities.SingleVariableConstraints{Float64}( - [0x0000], - [-Inf], - [Inf], - ) + @test a == + MOI.Utilities.VariablesContainer{Float64}([0x0000], [-Inf], [Inf]) return end @@ -65,20 +54,19 @@ function test__flag_to_set_type() end function test_add_constraint() - a = MOI.Utilities.SingleVariableConstraints{Int}() + a = MOI.Utilities.VariablesContainer{Int}() x = MOI.add_variable(a) - @test a == - MOI.Utilities.SingleVariableConstraints{Int}([0x0000], Int[0], Int[0]) + @test a == MOI.Utilities.VariablesContainer{Int}([0x0000], Int[0], Int[0]) f = MOI.SingleVariable(x) MOI.add_constraint(a, f, MOI.GreaterThan(3)) - @test a == MOI.Utilities.SingleVariableConstraints{Int}([0x0002], [3], [0]) + @test a == MOI.Utilities.VariablesContainer{Int}([0x0002], [3], [0]) MOI.add_constraint(a, f, MOI.LessThan(4)) - @test a == MOI.Utilities.SingleVariableConstraints{Int}([0x0006], [3], [4]) + @test a == MOI.Utilities.VariablesContainer{Int}([0x0006], [3], [4]) return end function test_add_constraint_LowerBoundAlreadySet() - a = MOI.Utilities.SingleVariableConstraints{Int}() + a = MOI.Utilities.VariablesContainer{Int}() x = MOI.add_variable(a) f = MOI.SingleVariable(x) MOI.add_constraint(a, f, MOI.GreaterThan(3)) @@ -90,7 +78,7 @@ function test_add_constraint_LowerBoundAlreadySet() end function test_add_constraint_UpperBoundAlreadySet() - a = MOI.Utilities.SingleVariableConstraints{Int}() + a = MOI.Utilities.VariablesContainer{Int}() x = MOI.add_variable(a) f = MOI.SingleVariable(x) MOI.add_constraint(a, f, MOI.LessThan(3)) @@ -102,7 +90,7 @@ function test_add_constraint_UpperBoundAlreadySet() end function test_delete_constraint_LessThan() - a = MOI.Utilities.SingleVariableConstraints{Int}() + a = MOI.Utilities.VariablesContainer{Int}() x = MOI.add_variable(a) f = MOI.SingleVariable(x) c = MOI.add_constraint(a, f, MOI.LessThan(3)) @@ -113,20 +101,18 @@ function test_delete_constraint_LessThan() end function test_delete_variable() - a = MOI.Utilities.SingleVariableConstraints{Int}() + a = MOI.Utilities.VariablesContainer{Int}() x = MOI.add_variable(a) - @test a == - MOI.Utilities.SingleVariableConstraints{Int}([0x0000], Int[0], Int[0]) + @test a == MOI.Utilities.VariablesContainer{Int}([0x0000], Int[0], Int[0]) f = MOI.SingleVariable(x) c = MOI.add_constraint(a, f, MOI.LessThan(3)) MOI.delete(a, x) - @test a == - MOI.Utilities.SingleVariableConstraints{Int}([0x8000], Int[0], Int[3]) + @test a == MOI.Utilities.VariablesContainer{Int}([0x8000], Int[0], Int[3]) return end function test_delete_constraint_GreaterThan() - a = MOI.Utilities.SingleVariableConstraints{Int}() + a = MOI.Utilities.VariablesContainer{Int}() x = MOI.add_variable(a) f = MOI.SingleVariable(x) c = MOI.add_constraint(a, f, MOI.GreaterThan(3)) @@ -137,22 +123,19 @@ function test_delete_constraint_GreaterThan() end function test_set_ConstraintSet() - a = MOI.Utilities.SingleVariableConstraints{Int}() + a = MOI.Utilities.VariablesContainer{Int}() x = MOI.add_variable(a) - @test a == - MOI.Utilities.SingleVariableConstraints{Int}([0x0000], Int[0], Int[0]) + @test a == MOI.Utilities.VariablesContainer{Int}([0x0000], Int[0], Int[0]) f = MOI.SingleVariable(x) c = MOI.add_constraint(a, f, MOI.GreaterThan(3)) - @test a == - MOI.Utilities.SingleVariableConstraints{Int}([0x0002], Int[3], Int[0]) + @test a == MOI.Utilities.VariablesContainer{Int}([0x0002], Int[3], Int[0]) MOI.set(a, MOI.ConstraintSet(), c, MOI.GreaterThan(2)) - @test a == - MOI.Utilities.SingleVariableConstraints{Int}([0x0002], Int[2], Int[0]) + @test a == MOI.Utilities.VariablesContainer{Int}([0x0002], Int[2], Int[0]) return end function test_NumberOfConstraints() - b = MOI.Utilities.SingleVariableConstraints( + b = MOI.Utilities.VariablesContainer( [0x0008, 0x0002, 0x0004, 0x0006], [1.0, 3.0, -Inf, -1.0], [2.0, Inf, 4.0, 1.0], @@ -166,7 +149,7 @@ function test_NumberOfConstraints() end function test_ListOfConstraintTypesPresent() - b = MOI.Utilities.SingleVariableConstraints( + b = MOI.Utilities.VariablesContainer( [0x0008, 0x0002, 0x0004, 0x0006], [1.0, 3.0, -Inf, -1.0], [2.0, Inf, 4.0, 1.0], @@ -180,7 +163,7 @@ function test_ListOfConstraintTypesPresent() end function test_ListOfConstraintIndices() - b = MOI.Utilities.SingleVariableConstraints{Float64}( + b = MOI.Utilities.VariablesContainer{Float64}( [0x0008, 0x0002, 0x0004, 0x0006], [1.0, 3.0, -Inf, -1.0], [2.0, Inf, 4.0, 1.0], @@ -260,7 +243,7 @@ function test_set_from_constants() end function _test_bound_vectors(::Type{T}, nolb, noub) where {T} - variable_bounds = MOI.Utilities.SingleVariableConstraints{T}() + variable_bounds = MOI.Utilities.VariablesContainer{T}() @test variable_bounds.lower == T[] @test variable_bounds.upper == T[] x = MOI.add_variable(variable_bounds) @@ -326,7 +309,7 @@ function test_ListOfConstraintTypesPresent_2() MOI.Integer(), MOI.ZeroOne(), ) - model = MOI.Utilities.SingleVariableConstraints{Float64}() + model = MOI.Utilities.VariablesContainer{Float64}() x = MOI.add_variable(model) MOI.add_constraint(model, MOI.SingleVariable(x), set) @test MOI.get(model, MOI.ListOfConstraintTypesPresent()) == From d32a78b59871397450b96d7579ebf20f8ac6bf3a Mon Sep 17 00:00:00 2001 From: odow Date: Thu, 12 Aug 2021 11:41:47 +1200 Subject: [PATCH 2/2] Fix tests --- ...objective_function_container.jl => objective_container.jl} | 0 test/Utilities/{vector_bounds.jl => variable_container.jl} | 4 ++-- 2 files changed, 2 insertions(+), 2 deletions(-) rename test/Utilities/{objective_function_container.jl => objective_container.jl} (100%) rename test/Utilities/{vector_bounds.jl => variable_container.jl} (99%) diff --git a/test/Utilities/objective_function_container.jl b/test/Utilities/objective_container.jl similarity index 100% rename from test/Utilities/objective_function_container.jl rename to test/Utilities/objective_container.jl diff --git a/test/Utilities/vector_bounds.jl b/test/Utilities/variable_container.jl similarity index 99% rename from test/Utilities/vector_bounds.jl rename to test/Utilities/variable_container.jl index 8ff9887487..62c55bfcc8 100644 --- a/test/Utilities/vector_bounds.jl +++ b/test/Utilities/variable_container.jl @@ -1,4 +1,4 @@ -module TestBox +module TestVariableContainer using Test import MathOptInterface @@ -320,4 +320,4 @@ end end # module -TestBox.runtests() +TestVariableContainer.runtests()