[UPD] Add a proper switch to cuts pruning

Author: frapac

src/SDDPoptimize.jl

@@ -108,7 +108,14 @@ function run_SDDP!(model::SPModel,
 
     #Initialization of the counter
     stats = SDDPStat()
-    activecuts = (param.pruning[:type] ∈ ["level1", "exact+"])? [ActiveCutsContainer(model.dimStates) for i in 1:model.stageNumber-1]: nothing
+
+    # Initialize cuts container for cuts pruning:
+    if isa(param.pruning[:type], Union{Type{Territory}, Type{LevelOne}})
+        activecuts = [ActiveCutsContainer(model.dimStates) for i in 1:model.stageNumber-1]
+    else
+        activecuts = [nothing for i in 1:model.stageNumber-1]
+    end
+
     (verbose > 0) && println("Initialize cuts")
 
     # If computation of upper-bound is needed, a set of scenarios is built

src/cutpruning.jl

@@ -6,7 +6,7 @@
 #############################################################################
 
 type ActiveCutsContainer
-    ncuts::Int
+    numCuts::Int
     territories::Array{Array} #set of states where cut k is active
     nstates::Int
     states::Array{Float64, 2} #set of states where cuts are tested
@@ -59,15 +59,15 @@ function prune_cuts!(model::SPModel,
                     param::SDDPparameters,
                     V::Vector{PolyhedralFunction},
                     trajectories::Array{Float64, 3},
-                    territory::Union{Void, Array{ActiveCutsContainer}},
+                    territory::Union{Array{Void}, Array{ActiveCutsContainer}},
                     it::Int64,
                     verbose::Int64)
     # Basic pruning: remove redundant cuts
     remove_redundant_cuts!(V)
 
     # If pruning is performed with territory heuristic, update territory
     # at given iteration:
-    if param.pruning[:type] ∈ ["level1", "exact+"]
+    if isa(param.pruning[:type], Union{Type{Territory}, Type{LevelOne}})
         for t in 1:model.stageNumber-1
             states = reshape(trajectories[t, :, :], param.forwardPassNumber, model.dimStates)
             find_level1_cuts!(territory[t], V[t], states)
@@ -81,16 +81,7 @@ function prune_cuts!(model::SPModel,
         (verbose > 0) && print("Prune cuts ...")
 
         for i in 1:length(V)-1
-            if param.pruning[:type] == "exact"
-                # apply exact cuts pruning:
-                V[i] = exact_cuts_pruning(model, param, V[i])
-            elseif param.pruning[:type] == "level1"
-                # apply heuristic to prune cuts:
-                V[i] = level1_cuts_pruning!(territory[i], V[i])
-            elseif param.pruning[:type] == "exact+"
-                # apply heuristicly accelerated exact pruning:
-                V[i] = exact_cuts_pruning_accelerated!(model, territory[i], V[i], param.SOLVER)
-            end
+            V[i] = pcuts!(param.pruning[:type], model, param, V[i], territory[i])
         end
 
         # final number of cuts:
@@ -100,6 +91,10 @@ function prune_cuts!(model::SPModel,
     end
 end
 
+pcuts!(::Type{LevelOne}, model, param, V, territory) = level1_cuts_pruning!(model, param, V, territory)
+pcuts!(::Type{ExactPruning}, model, param, V, territory) = exact_cuts_pruning(model, param, V, territory)
+pcuts!(::Type{Territory}, model, param, V, territory) = exact_cuts_pruning_accelerated!(model, param, V, territory)
+
 
 """
 Remove useless cuts in PolyhedralFunction.
@@ -113,7 +108,7 @@ Remove useless cuts in PolyhedralFunction.
 # Return
 * `PolyhedralFunction`: pruned polyhedral function
 """
-function exact_cuts_pruning(model::SPModel, param::SDDPparameters, V::PolyhedralFunction)
+function exact_cuts_pruning(model::SPModel, param::SDDPparameters, V::PolyhedralFunction, territory)
     ncuts = V.numCuts
     # Find all active cuts:
     if ncuts > 1
@@ -175,7 +170,7 @@ ActiveCutsContainer(ndim) = ActiveCutsContainer(0, [], 0, Array{Float64}(0, ndim
 # Arguments
 * `cutscontainer::ActiveCutsContainer`:
 * `Vt::PolyhedralFunction`:
-    Object storing all cuts   
+    Object storing all cuts
 * `states`:
     Object storing all visited states
 """
@@ -206,8 +201,8 @@ end
 # Arguments
 * `cutscontainer::ActiveCutsContainer`:
 * `V::PolyhedralFunction`:
-    Object storing all cuts  
-* `indcut::Int64`: 
+    Object storing all cuts
+* `indcut::Int64`:
     new cut index
 """
 function update_territory!(cutscontainer::ActiveCutsContainer, V::PolyhedralFunction, indcut::Int64)
@@ -256,12 +251,13 @@ end
 # Arguments
 * `cutscontainer::ActiveCutsContainer`:
 * `V::PolyhedralFunction`:
-    Object storing all cuts  
+    Object storing all cuts
 # Return
 * `V::PolyhedralFunction`
     the new PolyhedralFunction
 """
-function level1_cuts_pruning!(cutscontainer::ActiveCutsContainer, V::PolyhedralFunction)
+function level1_cuts_pruning!(model::SPModel, param::SDDPparameters,
+                              V::PolyhedralFunction, cutscontainer::ActiveCutsContainer)
     assert(cutscontainer.numCuts == V.numCuts)
 
     nstates = [length(terr) for terr in cutscontainer.territories]
@@ -284,16 +280,18 @@ then test remaining cuts.
 * `model::SPModel`:
 * `cutscontainer::ActiveCutsContainer`:
 * `V::PolyhedralFunction`:
-    Object storing all cuts  
-    
+    Object storing all cuts
+
 # Return
 * `V::PolyhedralFunction`
     the new PolyhedralFunction
 """
-function exact_cuts_pruning_accelerated!(model::SPModel,
-                                         cutscontainer::ActiveCutsContainer,
-                                         V::PolyhedralFunction, solver)
+function exact_cuts_pruning_accelerated!(model::SPModel, param::SDDPparameters,
+                                         V::PolyhedralFunction,
+                                         cutscontainer::ActiveCutsContainer)
+
     assert(cutscontainer.numCuts == V.numCuts)
+    solver = param.SOLVER
 
     nstates = [length(terr) for terr in cutscontainer.territories]
     # Set of inactive cuts:
@@ -326,8 +324,8 @@ end
 # Arguments
 * `xf::Vector{Float64}`:
 * `V::PolyhedralFunction`:
-    Object storing all cuts  
-    
+    Object storing all cuts
+
 # Return
 `bestcost::Float64`
     Value of maximal cut at point `xf`

src/objects.jl

@@ -138,7 +138,11 @@ type StochDynProgModel <: SPModel
 
 end
 
-
+# Define alias for cuts pruning algorithm:
+typealias LevelOne Val{:LevelOne}
+typealias ExactPruning Val{:Exact}
+typealias Territory Val{:Exact_Plus}
+typealias NoPruning Val{:none}
 
 type SDDPparameters
     # Solver used to solve LP
@@ -178,7 +182,15 @@ type SDDPparameters
         accparams = is_acc? Dict(:ρ0=>rho0, :alpha=>alpha, :rho=>rho0): Dict()
 
         pruning_algo = (prune_cuts>0)? pruning_algo: "none"
-        prune_cuts = Dict(:pruning=>prune_cuts>0, :period=>prune_cuts, :type=>pruning_algo)
+        prune_cuts = (pruning_algo != "none")? prune_cuts: 0
+
+        corresp = Dict("none"=>NoPruning,
+                       "level1"=>LevelOne,
+                       "exact+"=>Territory,
+                       "exact"=>ExactPruning)
+        prune_cuts = Dict(:pruning=>prune_cuts>0,
+                          :period=>prune_cuts,
+                          :type=>corresp[pruning_algo])
         return new(solver, mipsolver, passnumber, gap,
                    max_iterations, prune_cuts, compute_ub,
                    montecarlo_final, montecarlo_in_iter, is_acc, accparams)

test/sddp.jl

@@ -120,13 +120,13 @@ facts("SDDP algorithm: 1D case") do
 
         terr = StochDynamicProgramming.ActiveCutsContainer(2)
         StochDynamicProgramming.find_level1_cuts!(terr, vt, [0. 0.; 1. 0.])
-        @fact terr.ncuts --> 2
+        @fact terr.numCuts --> 2
         @fact terr.nstates --> 2
         @fact length(terr.territories[1]) --> 2
         @fact length(terr.territories[2]) --> 0
 
         # Check heuristic removal:
-        vt2 = StochDynamicProgramming.level1_cuts_pruning!(terr, vt)
+        vt2 = StochDynamicProgramming.level1_cuts_pruning!(model, param, vt, terr)
         @fact isa(vt2, StochDynamicProgramming.PolyhedralFunction) --> true
         @fact vt2.numCuts --> 1
         @fact vt2.betas[1] --> vt.betas[1]