Merge pull request #65 from JuliaStochOpt/bl/jumpv0.21

Update to JuMP v0.21

Author: blegat

Project.toml

@@ -6,11 +6,13 @@ version = "0.1.2"
 [deps]
 JuMP = "4076af6c-e467-56ae-b986-b466b2749572"
 MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee"
+MutableArithmetics = "d8a4904e-b15c-11e9-3269-09a3773c0cb0"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 
 [compat]
-JuMP = "0.20"
+JuMP = "0.21.1"
 MathOptInterface = "0.9.1"
+MutableArithmetics = "0.2.2"
 julia = "1"
 
 [extras]

README.md

@@ -84,7 +84,7 @@ We can also solve it for different values of `a`.
 
 ```julia
 # Create a JuMP model able to handle parameters
-model = ModelWithParams(with_optimizer(SOME_SOLVER.Optimizer))
+model = ModelWithParams(SOME_SOLVER.Optimizer)
 
 # Create a regular JuMP variable
 @variable(model, x)
@@ -147,7 +147,7 @@ One example in pure JuMP goes as follows:
 
 ```julia
 # create a regular JuMP Model
-model_pure = Model(with_optimizer(SOME_SOLVER.Optimizer))
+model_pure = Model(SOME_SOLVER.Optimizer)
 
 # add optimization variables
 @variable(model_pure, x[1:N] >= 0)
@@ -191,7 +191,7 @@ The same example of the motivation can be written with **parameters**:
 
 ```julia
 # create a regular JuMP Model
-model_pure = Model(with_optimizer(SOME_SOLVER.Optimizer))
+model_pure = Model(SOME_SOLVER.Optimizer)
 
 # add optimization variables
 @variable(model_pure, x[1:N] >= 0)

benchmarks/bench.jl

@@ -8,7 +8,7 @@ using Profile
 using ProfileView
 
 function bench1_p(N::Int, M::Int)
-    m_slave = ModelWithParams(with_optimizer(GLPK.Optimizer))
+    m_slave = ModelWithParams(GLPK.Optimizer)
 
     x = add_parameters(m_slave, 4.0*ones(M))
     @variable(m_slave, y[1:N])
@@ -20,7 +20,7 @@ function bench1_p(N::Int, M::Int)
     end
 end
 function bench1_v(N::Int, M::Int)
-    m_slave = Model(with_optimizer(GLPK.Optimizer))
+    m_slave = Model(GLPK.Optimizer)
 
     @variable(m_slave, x[1:M] == 4.0)
     @variable(m_slave, y[1:N])
@@ -32,7 +32,7 @@ function bench1_v(N::Int, M::Int)
     end
 end
 function bench2_p(N::Int)
-    m_slave = ModelWithParams(with_optimizer(GLPK.Optimizer))
+    m_slave = ModelWithParams(GLPK.Optimizer)
 
     x = add_parameters(m_slave, 4.0*ones(N))
     @variable(m_slave, y[1:N])
@@ -44,7 +44,7 @@ function bench2_p(N::Int)
     end
 end
 function bench2_v(N::Int)
-    m_slave = Model(with_optimizer(GLPK.Optimizer))
+    m_slave = Model(GLPK.Optimizer)
 
     @variable(m_slave, x[1:N] == 4.0)
     @variable(m_slave, y[1:N])

benchmarks/bench2.jl

@@ -70,7 +70,7 @@ end
 =#
 
 function bench_create_param(N_Parameters::Int, N_Variables::Int, N_Constraints::Int)
-    model = ModelWithParams(with_optimizer(GLPK.Optimizer))
+    model = ModelWithParams(GLPK.Optimizer)
     @timeit to "create params" x = add_parameters2(model, N_Parameters)
     @timeit to "create vars" y = add_variables(model, N_Variables)
 
@@ -104,4 +104,4 @@ reset_timer!(to)
 bench_create_param(1000, 1000, 1000)
 
 
-show(to)
+show(to)

src/ParameterJuMP.jl

@@ -2,6 +2,9 @@ module ParameterJuMP
 
 using SparseArrays
 
+import MutableArithmetics
+const MA = MutableArithmetics
+
 using JuMP
 export index
 using MathOptInterface
@@ -259,7 +262,7 @@ to the regular `Model` constructor.
 Example using GLPK solver:
 
 ```julia
-    model = ModelWithParams(with_optimizer(GLPK.Optimizer))
+model = ModelWithParams(GLPK.Optimizer)
 ```
 """
 function ModelWithParams(args...; kwargs...)

src/mutable_arithmetics.jl

@@ -1,74 +1,23 @@
-
-# destructive_add!
-# ------------------------------------------------------------------------------
-
-# destructive_add!{C}(ex::Number, c::Number, x::Number) = ex + c*x
-
-#=
-    Number
-=#
-
-JuMP.destructive_add!(ex::Number, c::C, x::ParameterRef) where C<:Number = PAE{C}(GAEv{C}(ex),GAEp{C}(zero(C), x => c))
-JuMP.destructive_add!(ex::Number, x::ParameterRef, c::C) where C<:Number = JuMP.destructive_add!(ex, c, x)
-JuMP.destructive_add!(ex::Number, c::C, x::PAE) where C<:Number = PAE{C}(JuMP.destructive_add!(ex, c, x.v), JuMP.destructive_add!(0.0, c, x.p))
-
-#=
-    VariableRef
-=#
-
-JuMP.destructive_add!(ex::JuMP.VariableRef, c::C, x::ParameterRef) where C<:Number = PAE{C}(GAEv{C}(zero(C), ex => one(C)), GAEp{C}(zero(C), x => c))
-JuMP.destructive_add!(ex::JuMP.VariableRef, x::ParameterRef, c::C) where C<:Number = JuMP.destructive_add!(ex, c, x)
-
-#=
-    Parameter
-=#
-
-JuMP.destructive_add!(ex::ParameterRef, c::Number, x::Number) = c * x + ex
-
-JuMP.destructive_add!(ex::ParameterRef, c::C, x::JuMP.VariableRef) where C<:Number = PAE{C}(GAEv{C}(zero(C), x => c), GAEp{C}(zero(C), ex => one(C)))
-JuMP.destructive_add!(ex::ParameterRef, x::JuMP.VariableRef, c::Number) = JuMP.destructive_add!(ex, c, x)
-
-JuMP.destructive_add!(ex::ParameterRef, c::C, x::ParameterRef) where {C<:Number} = PAE{C}(zero(GAEv{C}),  GAEp{C}(zero(C), ex => one(C), x => c))
-JuMP.destructive_add!(ex::ParameterRef, x::ParameterRef, c::C) where {C<:Number} = JuMP.destructive_add!(ex, x, c)
-
-#=
-    GAEp
-=#
-
-JuMP.destructive_add!(aff::GAEp{C}, c::Number, x::Number) where {C} = PAE{C}(GAEv{C}(c*x), aff)
-
-JuMP.destructive_add!(aff::GAEp{C}, x::Union{JuMP.VariableRef, GAEv{C}}, c::Number) where C = JuMP.destructive_add!(aff, c, x)
-JuMP.destructive_add!(aff::GAEp{C}, c::Number, x::Union{JuMP.VariableRef, GAEv{C}}) where C = PAE{C}(GAEv{C}(zero(C), x => convert(C, c)), aff)
-
-#=
-    GAEv
-=#
-
-JuMP.destructive_add!(aff::GAEv{C}, x::Union{ParameterRef, GAEp{C}}, c::Number) where C = JuMP.destructive_add!(aff, c, x)
-JuMP.destructive_add!(aff::GAEv{C}, c::Number, x::Union{ParameterRef, GAEp{C}}) where C = PAE{C}(aff, GAEp{C}(zero(C), x => convert(C, c)))
-
-#=
-    PAE
-=#
-
-JuMP.destructive_add!(aff::PAE, x::Union{JuMP.VariableRef, GAEv, ParameterRef, GAEp}, c::Number) = JuMP.destructive_add!(aff, c, x)
-function JuMP.destructive_add!(aff::PAE, c::Number, x::Union{JuMP.VariableRef, GAEv})
+function MA.mutable_operate!(op::MA.AddSubMul, aff::PAE, x::Union{JuMP.VariableRef, GAEv, ParameterRef, GAEp}, c::Number)
+    return MA.mutable_operate!(op, aff, c, x)
+end
+function MA.mutable_operate!(op::MA.AddSubMul, aff::PAE, c::Number, x::Union{JuMP.VariableRef, GAEv})
     if !iszero(c)
-        aff.v = JuMP.destructive_add!(aff.v, c, x)
+        MA.mutable_operate!(op, aff.v, c, x)
     end
-    aff
+    return aff
 end
-function JuMP.destructive_add!(aff::PAE, c::Number, x::Union{ParameterRef, GAEp})
+function MA.mutable_operate!(op::MA.AddSubMul, aff::PAE, c::Number, x::Union{ParameterRef, GAEp})
     if !iszero(c)
-        aff.p = JuMP.destructive_add!(aff.p, c, x)
+        MA.mutable_operate!(op, aff.p, c, x)
     end
-    aff
+    return aff
 end
-function JuMP.destructive_add!(aff::PAE, c::Number, x::Number)
-    if !iszero(c)
-        aff.v = JuMP.destructive_add!(aff.v, c, x)
+function MA.mutable_operate!(op::MA.AddSubMul, aff::PAE, c::Number, x::Number)
+    if !iszero(c) && !iszero(x)
+        aff.v = MA.mutable_operate!(op, aff.v, c, x)
     end
-    aff
+    return aff
 end
 
 function JuMP.add_to_expression!(aff::PAE, other::Number)
@@ -95,4 +44,4 @@ end
 function JuMP.add_to_expression!(lhs_aff::PAE, rhs_aff::PAE)
     JuMP.add_to_expression!(lhs_aff.p, rhs_aff.p)
     JuMP.add_to_expression!(lhs_aff.v, rhs_aff.v)
-end
+end

src/operators.jl

@@ -100,6 +100,7 @@ Base.:(-)(lhs::GAEp{C}, rhs::GAEv{C}) where {C} = (+)(-rhs,lhs)
 # DONE in JuMP
 
 # GenericAffExpr{C,ParameterRef}--PAE{C}
+Base.:(+)(lhs::GAEp{C}, rhs::PAE{C}) where {C} = PAE{C}(rhs.v, lhs + rhs.p)
 
 #=
     PAE{C}

test/runtests.jl

@@ -6,7 +6,7 @@ using JuMP
 using ParameterJuMP
 
 using GLPK
-factory = with_optimizer(GLPK.Optimizer)
+factory = GLPK.Optimizer
 
 include("tests.jl")
 

test/tests.jl

@@ -442,6 +442,8 @@ function test14(args...)
         @test_expression_with_string b - a - 1.2 "b - a - 1.2"
         # var + par + num
         @test_expression_with_string x + a + 1.2 "x + a + 1.2"
+        # var + par + num * num
+        @test_expression_with_string x + a + 1.2 * 2.0 "x + a + 2.4"
         # var + var + par + num
         @test_expression_with_string x + y + a + 1.2 "x + y + a + 1.2"
         # var + var - par + num