[UPD] Synchronize different interfaces

Author: frapac

src/SDDPoptimize.jl

@@ -41,8 +41,7 @@ function solve_SDDP(model::SPModel,
                     param::SDDPparameters,
                     display=0::Int64,
                     V=nothing,
-                    V_final=nothing,
-                    returnValueFunctions=true::Bool)
+                    V_final=nothing)
 
     # First step: process terminal costs.
     # If not specified, default value is null functions
@@ -55,13 +54,13 @@ function solve_SDDP(model::SPModel,
     # Second step: process value functions if hotstart is called
     if isa(V, Vector{PolyhedralFunction})
         # If V is already specified, then call hotstart:
-        problems = hotstart(model, param, V)
+        problems = SDDP_hotstart(model, param, V)
     else
         # Otherwise, initialize value functions:
         V, problems = initialize_value_functions(model, param, Vf)
     end
 
-    return run_SDDP(model, param, V, problems, display, returnValueFunctions)
+    return run_SDDP(model, param, V, problems, display)
 end
 
 
@@ -70,10 +69,9 @@ end
 """
 function run_SDDP(model::SPModel,
                     param::SDDPparameters,
-                    V::Array{PolyhedralFunction, 1},
+                    V::Vector{PolyhedralFunction},
                     problems::Vector{JuMP.Model},
-                    display=0::Int64,
-                    returnValueFunctions=true::Bool)
+                    display=0::Int64)
 
     # Evaluation of initial cost:
     V0::Float64 = 0
@@ -110,14 +108,11 @@ function run_SDDP(model::SPModel,
                       problems,
                       stockTrajectories,
                       model.noises,
-                      false,
-                      returnValueFunctions)
+                      false)
 
         iteration_count += 1
 
 
-
-
         if (display > 0) && (iteration_count%display==0)
             println("Pass number ", iteration_count,
                     "\tLower-bound: ", round(get_bellman_value(model, param, 1, V[1], model.initialState),4),
@@ -169,14 +164,14 @@ Return:
 Float64 (estimation of the upper bound)
 
 """
-function estimate_upper_bound(model, param, V, problems, n_simulation=1000)
+function estimate_upper_bound(model::SPmodel, param::SDDPparameters, V::Vector{PolyhedralFunction}, problem::Vector{JuMP.Model}, n_simulation=1000::Int)
 
     aleas = simulate_scenarios(model.noises, n_simulation)
 
     costs, stockTrajectories, _ = forward_simulations(model,
                                                         param,
                                                         V,
-                                                        problems,
+                                                        problem,
                                                         aleas)
 
     return upper_bound(costs), costs
@@ -210,7 +205,7 @@ Parameter:
     Else, terminal cost is null
 
 """
-function build_terminal_cost!(model::SPModel, problem::JuMP.Model, Vt)
+function build_terminal_cost!(model::SPModel, problem::JuMP.Model, Vt::PolyhedralFunction)
     alpha = getVar(problem, :alpha)
 
     # if shape is PolyhedralFunction, build terminal cost with it:
@@ -370,7 +365,7 @@ Parameters:
     Estimation of bellman functions as Polyhedral functions
 
 """
-function hotstart(model::SPModel, param::SDDPparameters, V::Vector{PolyhedralFunction})
+function SDDP_hotstart(model::SPModel, param::SDDPparameters, V::Vector{PolyhedralFunction})
 
     solverProblems = build_models(model, param)
 
@@ -470,7 +465,7 @@ Return:
     Vector{Float64}: optimal control at time t
 
 """
-function get_control(model::SPModel, param::SDDPparameters, lpproblem::Vector{JuMP.Model}, t, xt, xi)
+function get_control(model::SPModel, param::SDDPparameters, lpproblem::Vector{JuMP.Model}, t::Int, xt::Vector{Float64}, xi::Vector{Float64})
     return solve_one_step_one_alea(model, param, lpproblem[t], t, xt, xi)[2].optimal_control
 end
 
@@ -504,3 +499,4 @@ function add_cuts_to_model!(model::SPModel, t::Int64, problem::JuMP.Model, V::Po
         @addConstraint(problem, V.betas[i] + dot(lambda, model.dynamics(t, x, u, w)) <= alpha)
     end
 end
+

src/SDPoptimize.jl

@@ -12,6 +12,7 @@ using ProgressMeter
 using Iterators
 using Interpolations
 
+
 """
 Convert the state and control float tuples (stored as arrays or tuples) of the
 problem into integer tuples that can be used as indexes for the value function
@@ -39,6 +40,7 @@ function index_from_variable( variable,
     return tuple([ 1 + floor(Int64,(1e-10+( variable[i] - bounds[i][1] )/ variable_steps[i] )) for i in 1:length(variable)]...)
 end
 
+
 """
 Convert the state and control float tuples (stored as arrays or tuples) of the
 problem into float tuples that can be used as indexes for the interpolated
@@ -67,6 +69,7 @@ function real_index_from_variable( variable,
     return tuple([1 + ( variable[i] - bounds[i][1] )/variable_steps[i] for i in 1:length(variable)]...)
 end
 
+
 """
 Compute interpolation of the value function at time t
 
@@ -91,6 +94,7 @@ function value_function_interpolation( model::SPModel,
     return interpolate(V[[Colon() for i in 1:model.dimStates]...,time], BSpline(Linear()), OnGrid())
 end
 
+
 """
 Compute interpolation of the value function at time t
 
@@ -113,9 +117,9 @@ function generate_grid(model::SPModel, param::SDPparameters)
     product_controls = product([model.ulim[i][1]:param.controlSteps[i]:model.ulim[i][2] for i in 1:model.dimControls]...)
 
     return product_states, product_controls
-
 end
 
+
 """
 Transform a general SPmodel into a StochDynProgModel
 
@@ -161,6 +165,7 @@ function build_sdpmodel_from_spmodel(model::SPModel)
     return SDPmodel
 end
 
+
 """
 Value iteration algorithm to compute optimal value functions in
 the Decision Hazard (DH) as well as the Hazard Decision (HD) case
@@ -325,6 +330,7 @@ function sdp_solve_DH(model::StochDynProgModel,
     return V
 end
 
+
 """
 Value iteration algorithm to compute optimal value functions in
 the Hazard Decision (HD) case
@@ -450,6 +456,7 @@ function sdp_solve_HD(model::StochDynProgModel,
     return V
 end
 
+
 """
 Get the optimal value of the problem from the optimal Bellman Function
 
@@ -465,13 +472,15 @@ Parameters:
 
 Returns :
 - V(x0) (Float64)
+
 """
 function get_value(model::SPModel,param::SDPparameters,V::Array{Float64})
     ind_x0 = real_index_from_variable(model.initialState, model.xlim, param.stateSteps)
     Vi = value_function_interpolation(model, V, 1)
     return Vi[ind_x0...,1]
 end
 
+
 """
 Simulation of optimal trajectories given model and Bellman functions
 
@@ -503,6 +512,7 @@ Returns :
 
 - controls (Array{Float64})
     the controls applied to the system at each time step
+
 """
 function sdp_forward_simulation(model::SPModel,
                   param::SDPparameters,
@@ -521,13 +531,14 @@ function sdp_forward_simulation(model::SPModel,
 
     for k = 1:nb_scenarios
         #println(k)
-        costs[k],states[:,k], controls[:,k] = sdp_forward_single_simulation(SDPmodel,
+        costs[k], states[:,k], controls[:,k] = sdp_forward_single_simulation(SDPmodel,
                   param,scenarios[:,k],model.initialState,value,display)
     end
 
-    return costs, controls, states
+    return costs, states, controls
 end
 
+
 """
 Get the optimal control at time t knowing the state of the system in the decision hazard case
 
@@ -552,6 +563,7 @@ the alea realization
 
 Returns :
 - V(x0) (Float64)
+
 """
 function get_control(model::SPModel,param::SDPparameters,V::Array{Float64}, t::Int64, x::Array)
 
@@ -608,6 +620,7 @@ function get_control(model::SPModel,param::SDPparameters,V::Array{Float64}, t::I
     return best_control
 end
 
+
 """
 Get the optimal control at time t knowing the state of the system and the alea in the hazard decision case
 
@@ -632,6 +645,7 @@ the alea realization
 
 Returns :
 - V(x0) (Float64)
+
 """
 function get_control(model::SPModel,param::SDPparameters,V::Array{Float64}, t::Int64, x::Array, w::Array)
 
@@ -670,6 +684,7 @@ function get_control(model::SPModel,param::SDPparameters,V::Array{Float64}, t::I
 
 end
 
+
 """
 Simulation of optimal control given an initial state and an alea scenario
 

src/extensiveFormulation.jl

@@ -10,7 +10,7 @@
 Contruct the scenario tree and solve the problem with measurability constraints
 """
 function extensive_formulation(model,
-                               params)
+                               param)
 
 
     #Recover all the constant in the model or in param