[FIX] Fix indentations in forwardbackwarditerations.jl

Author: frapac

src/forwardBackwardIterations.jl

@@ -122,172 +122,172 @@ end
 """
 Add to polyhedral function a cut with shape Vt >= beta + <lambda,.>
 
-	Parameters:
-	- model (SPModel)
-	Store the problem definition
-
-	- t (Int64)
-	Current time
-
-	- Vt (PolyhedralFunction)
-	Current lower approximation of the Bellman function at time t
-
-		- beta (Float)
-		affine part of the cut to add
+Parameters:
+- model (SPModel)
+Store the problem definition
 
-		- lambda (Array{float,1})
-		subgradient of the cut to add
+- t (Int64)
+Current time
 
-		"""
-		function add_cut!(model::SPModel,
-			t::Int64, Vt::PolyhedralFunction,
-			beta::Float64, lambda::Vector{Float64})
-			Vt.lambdas = vcat(Vt.lambdas, reshape(lambda, 1, model.dimStates))
-			Vt.betas = vcat(Vt.betas, beta)
-			Vt.numCuts += 1
-		end
+- Vt (PolyhedralFunction)
+Current lower approximation of the Bellman function at time t
 
+- beta (Float)
+affine part of the cut to add
 
-		"""
-		Add a cut to the JuMP linear problem.
+- lambda (Array{float,1})
+subgradient of the cut to add
 
-		Parameters:
-		- model (SPModel)
-		Store the problem definition
+"""
+function add_cut!(model::SPModel,
+    t::Int64, Vt::PolyhedralFunction,
+    beta::Float64, lambda::Vector{Float64})
+    Vt.lambdas = vcat(Vt.lambdas, reshape(lambda, 1, model.dimStates))
+    Vt.betas = vcat(Vt.betas, beta)
+    Vt.numCuts += 1
+end
 
-		- problem (JuMP.Model)
-		Linear problem used to approximate the value functions
 
-		- t (Int)
-		Time index
+"""
+Add a cut to the JuMP linear problem.
 
-		- beta (Float)
-		affine part of the cut to add
+Parameters:
+- model (SPModel)
+Store the problem definition
 
-		- lambda (Array{float,1})
-		subgradient of the cut to add
+- problem (JuMP.Model)
+Linear problem used to approximate the value functions
 
-		"""
-		function add_cut_to_model!(model::SPModel, problem::JuMP.Model,
-			t::Int64, beta::Float64, lambda::Vector{Float64})
-			alpha = getVar(problem, :alpha)
-			x = getVar(problem, :x)
-			u = getVar(problem, :u)
-			w = getVar(problem, :w)
-			@addConstraint(problem, beta + dot(lambda, model.dynamics(t, x, u, w)) <= alpha)
-		end
+- t (Int)
+Time index
 
+- beta (Float)
+affine part of the cut to add
 
-		"""
-		Make a backward pass of the algorithm
+- lambda (Array{float,1})
+subgradient of the cut to add
 
-		For t:T-1 -> 0, compute a valid cut of the Bellman function
-			Vt at the state given by stockTrajectories and add them to
-			the current estimation of Vt.
+"""
+function add_cut_to_model!(model::SPModel, problem::JuMP.Model,
+    t::Int64, beta::Float64, lambda::Vector{Float64})
+    alpha = getVar(problem, :alpha)
+    x = getVar(problem, :x)
+    u = getVar(problem, :u)
+    w = getVar(problem, :w)
+    @addConstraint(problem, beta + dot(lambda, model.dynamics(t, x, u, w)) <= alpha)
+end
 
 
-			Parameters:
-			- model (SPmodel)
-			the stochastic problem we want to optimize
+"""
+Make a backward pass of the algorithm
 
-			- param (SDDPparameters)
-			the parameters of the SDDP algorithm
+For t:T-1 -> 0, compute a valid cut of the Bellman function
+Vt at the state given by stockTrajectories and add them to
+the current estimation of Vt.
 
-			- V (Array{PolyhedralFunction})
-			the current estimation of Bellman's functions
 
-			- solverProblems (Array{JuMP.Model})
-			Linear model used to approximate each value function
+Parameters:
+- model (SPmodel)
+the stochastic problem we want to optimize
 
-				- stockTrajectories (Array{Float64,3})
-				stockTrajectories[t,k,:] is the vector of stock where the cut is computed
-				for scenario k and time t.
+- param (SDDPparameters)
+the parameters of the SDDP algorithm
 
-					- law (Array{NoiseLaw})
-					Conditionnal distributions of perturbation, for each timestep
+- V (Array{PolyhedralFunction})
+the current estimation of Bellman's functions
 
-						- init (Bool)
-						If specified, then init PolyhedralFunction
+- solverProblems (Array{JuMP.Model})
+Linear model used to approximate each value function
 
-						- updateV (Bool)
-						Store new cuts in given Polyhedral functions if specified
+- stockTrajectories (Array{Float64,3})
+stockTrajectories[t,k,:] is the vector of stock where the cut is computed
+for scenario k and time t.
 
+- law (Array{NoiseLaw})
+Conditionnal distributions of perturbation, for each timestep
 
-							Return:
-							- V0 (Float64)
-							Approximation of initial cost
+- init (Bool)
+If specified, then init PolyhedralFunction
 
-							"""
-							function backward_pass!(model::SPModel,
-								param::SDDPparameters,
-								V::Vector{PolyhedralFunction},
-								solverProblems::Vector{JuMP.Model},
-								stockTrajectories::Array{Float64, 3},
-								law,
-								init=false::Bool)
+- updateV (Bool)
+Store new cuts in given Polyhedral functions if specified
 
-								T = model.stageNumber
-								nb_forward = size(stockTrajectories)[2]
 
-								# Estimation of initial cost:
-								V0 = 0.
+Return:
+- V0 (Float64)
+Approximation of initial cost
 
-								costs::Vector{Float64} = zeros(1)
-								costs_npass = zeros(Float64, nb_forward)
-								state_t = zeros(Float64, model.dimStates)
+"""
+function backward_pass!(model::SPModel,
+    param::SDDPparameters,
+    V::Vector{PolyhedralFunction},
+    solverProblems::Vector{JuMP.Model},
+    stockTrajectories::Array{Float64, 3},
+    law,
+    init=false::Bool)
 
-								for t = T-1:-1:1
-									costs = zeros(law[t].supportSize)
+    T = model.stageNumber
+    nb_forward = size(stockTrajectories)[2]
 
-									for k = 1:nb_forward
+    # Estimation of initial cost:
+    V0 = 0.
 
-										subgradient_array = zeros(Float64, model.dimStates, law[t].supportSize)
-										state_t = extract_vector_from_3Dmatrix(stockTrajectories, t, k)
+    costs::Vector{Float64} = zeros(1)
+    costs_npass = zeros(Float64, nb_forward)
+    state_t = zeros(Float64, model.dimStates)
 
-										for w in 1:law[t].supportSize
+    for t = T-1:-1:1
+        costs = zeros(law[t].supportSize)
 
-											alea_t  = collect(law[t].support[:, w])
+        for k = 1:nb_forward
 
-											nextstep = solve_one_step_one_alea(model,
-											param,
-											solverProblems[t],
-											t,
-											state_t,
-											alea_t)[2]
-											subgradient_array[:, w] = nextstep.sub_gradient
-											costs[w] = nextstep.cost
-										end
+            subgradient_array = zeros(Float64, model.dimStates, law[t].supportSize)
+            state_t = extract_vector_from_3Dmatrix(stockTrajectories, t, k)
 
-										# Compute expectation of subgradient:
-										subgradient = vec(sum(law[t].proba' .* subgradient_array, 2))
-										# ... and esperancy of cost:
-										costs_npass[k] = dot(law[t].proba, costs)
-										beta = costs_npass[k] - dot(subgradient, state_t)
+            for w in 1:law[t].supportSize
 
+                alea_t  = collect(law[t].support[:, w])
 
-										# Add cut to polyhedral function and JuMP model:
-										if init
-											V[t] = PolyhedralFunction([beta],
-											reshape(subgradient,
-											1,
-											model.dimStates), 1)
-											if t > 1
-												add_cut_to_model!(model, solverProblems[t-1], t, beta, subgradient)
-											end
+                nextstep = solve_one_step_one_alea(model,
+                param,
+                solverProblems[t],
+                t,
+                state_t,
+                alea_t)[2]
+                subgradient_array[:, w] = nextstep.sub_gradient
+                costs[w] = nextstep.cost
+            end
 
-										else
-											add_cut!(model, t, V[t], beta, subgradient)
-											if t > 1
-												add_cut_to_model!(model, solverProblems[t-1], t, beta, subgradient)
-											end
-										end
+            # Compute expectation of subgradient:
+            subgradient = vec(sum(law[t].proba' .* subgradient_array, 2))
+            # ... and esperancy of cost:
+            costs_npass[k] = dot(law[t].proba, costs)
+            beta = costs_npass[k] - dot(subgradient, state_t)
+
+
+            # Add cut to polyhedral function and JuMP model:
+            if init
+                V[t] = PolyhedralFunction([beta],
+                reshape(subgradient,
+                1,
+                model.dimStates), 1)
+                if t > 1
+                    add_cut_to_model!(model, solverProblems[t-1], t, beta, subgradient)
+                end
+
+            else
+                add_cut!(model, t, V[t], beta, subgradient)
+                if t > 1
+                    add_cut_to_model!(model, solverProblems[t-1], t, beta, subgradient)
+                end
+            end
 
-									end
+        end
 
-									if t==1
-										V0 = mean(costs_npass)
-									end
+        if t==1
+            V0 = mean(costs_npass)
+        end
 
-								end
-								return V0
-							end
+    end
+    return V0
+end