Merge pull request #103 from JuliaOpt/dev-nightly

V0.1.3

Author: leclere

.travis.yml

@@ -3,7 +3,6 @@ os:
   - linux
 julia:
   - release
-  - nightly
   - 0.4
 notifications:
   email: false

README.md

@@ -1,19 +1,21 @@
 # StochDynamicProgramming
 
 
-
 **WARNING:** *This package is currently in development. Any help or feedback is appreciated.*
 
 
-[![Build Status](https://travis-ci.org/leclere/StochDynamicProgramming.jl.svg?branch=master)](https://travis-ci.org/leclere/StochDynamicProgramming.jl)
-[![codecov.io](https://codecov.io/github/leclere/StochDynamicProgramming.jl/coverage.svg?branch=master)](https://codecov.io/github/leclere/StochDynamicProgramming.jl?branch=master)
+**Latest release:** 0.1.3
+
+
+[![Build Status](https://travis-ci.org/JuliaOpt/StochDynamicProgramming.jl.svg?branch=master)](https://travis-ci.org/JuliaOpt/StochDynamicProgramming.jl)
+[![codecov.io](https://codecov.io/github/JuliaOpt/StochDynamicProgramming.jl/coverage.svg?branch=master)](https://codecov.io/github/JuliaOpt/StochDynamicProgramming.jl?branch=master)
 
 
 This is a Julia package for optimizing controlled stochastic dynamic system (in discrete time). It offers three methods of resolution :
 
-- Extensive formulation
-- Stochastic Dynamic Programming.
-- *Stochastic Dual Dynamic Programming* (SDDP) algorithm. 
+- *Extensive formulation*.
+- *Stochastic Dynamic Programming*.
+- *Stochastic Dual Dynamic Programming* (SDDP) algorithm.
 
 It is built upon [JuMP](https://github.com/JuliaOpt/JuMP.jl)
 
@@ -22,12 +24,15 @@ It is built upon [JuMP](https://github.com/JuliaOpt/JuMP.jl)
 - Stage-wise independent discrete noise
 - Linear dynamics
 - Linear or convex piecewise linear cost
-Extension to non-linear formulation are under development.
+
+Extension to non-linear formulation are under development. 
+Extension to more complex alea dependance are under developpment.
 
 ## Why Extensive formulation ?
 
-An extensive formulation approach consists in representing the problem in a linear
-problem solved by an external linear solver. Complexity is exponential in number of stages. 
+An extensive formulation approach consists in representing the stochastic problem as a deterministic
+one with more variable and call a standard deterministic solver. Mainly usable in a linear 
+setting. Computational complexity is exponential in the number of stages.
 
 ## Why Stochastic Dynamic Programming ?
 
@@ -39,23 +44,26 @@ in the dimension of the state space.
 
 SDDP is a dynamic programming algorithm relying on cutting planes. The algorithm require convexity
 of the value function but does not discretize the state space. The complexity is linear in the
-number of stage, and can accomodate higher dimension state than standard dynamic programming. 
+number of stage, and can accomodate higher dimension state than standard dynamic programming.
 The algorithm return exact lower bound and estimated upper bound as well as approximate optimal
 control strategies.
 
 
 
 ## Installation
+Installing StochDynamicProgramming is an easy process. Open Julia and enter
 
-```bash
-Pkg.clone("https://github.com/leclere/StochDynamicProgramming.jl.git")
+```julia
+julia> Pkg.update()
+julia> Pkg.add("StochDynamicProgramming")
 
 ```
 
+
 ## Usage
 
 IJulia Notebooks will be provided to explain how this package work.
-A first example on a two dams valley [here.] (https://github.com/leclere/StochDP-notebooks/blob/master/notebooks/damsvalley.ipynb)
+A first example on a two dams valley [here.] (http://nbviewer.jupyter.org/github/leclere/StochDP-notebooks/blob/master/notebooks/damsvalley.ipynb)
 
 
 ## Documentation
@@ -74,3 +82,7 @@ cd doc
 make html
 
 ```
+
+## License
+
+Released under Mozilla Public License (see LICENSE.md for further details).

doc/index.rst

@@ -50,6 +50,7 @@ Contents:
    install
    quickstart
    tutorial
+   install_windows
 
 .. _MathProgBase: http://mathprogbasejl.readthedocs.org/en/latest/
 .. _here: http://www2.isye.gatech.edu/people/faculty/Alex_Shapiro/ONS-FR.pdf

doc/install.rst

@@ -12,6 +12,7 @@ To install StochDynamicProgramming::
 
     julia> Pkg.add("StochDynamicProgramming")
 
+
 Once the package is installed, you can import it in the REPL::
 
     julia> using StochDynamicProgramming

doc/install_windows.rst

@@ -0,0 +1,76 @@
+.. _install_windows:
+
+===========================================
+Install StochDynamicProgramming on Windows
+===========================================
+
+
+Installing Julia
+~~~~~~~~~~~~~~~~
+
+StochDynamicProgramming is a Julia package so if you want to use it, you
+need first to install Julia depending on whether your computer is 32-bit
+or 64-bit. To determine that, follow the steps
+`here <http://windows.microsoft.com/fr-fr/windows7/find-out-32-or-64-bit>`__.
+
+Once it is done, you can follow this
+`link <http://julialang.org/downloads/>`__ to install Julia (command
+line version) appropriate to your computer.
+
+Installing the package in Julia
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Open the Julia terminal using the desktop icon or looking for it in the
+search bar of Windows. Then copy-past or enter the following line::
+
+    julia> Pkg.add("StochDynamicProgramming.jl")
+
+Once it is done, you can use the package. To see where the files are located,
+you can enter the command::
+
+    julia> pwd()
+
+in the command line of Julia.
+
+Compiling the doc
+=================
+
+To compile the doc, you will need a C compiler to execute a makefile,
+Python and Sphinx installed.
+
+Installing Python and Sphinx
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Follow this
+`link <http://www.sphinx-doc.org/en/stable/install.html#windows-install-python-and-sphinx>`__
+to install Python and choose a version x86 if you want a 32-bits version
+and choose x86-64 if you want a 64 bits version. Be careful to add the
+PATH variable as it is explained.
+
+Installing MinGW
+~~~~~~~~~~~~~~~~
+
+Just follow the steps explained
+`here <http://www.mingw.org/wiki/Getting_Started>`__.
+
+Compiling the doc
+~~~~~~~~~~~~~~~~~
+
+Once you get Python, Sphinx and MinGW, open a command line. Go to
+StochDynamicProgramming folder. Enter::
+
+    cd doc
+
+and then::
+
+    make html
+
+Have a nice use
+===============
+
+| Now everything is installed, you can enjoy the use of the package. If
+you want some example, we invite you to try our Julia Notebooks available
+`here <https://github.com/leclere/StochDP-notebooks/blob/master/notebooks/damsvalley.ipynb>`__.
+ 
+| Don't hesitate to contact us if you encounter any problem to let us improve the
+document for further users !!

doc/tutorial.rst

@@ -15,7 +15,7 @@ Get Bellman value at a given point
 To estimate the Bellman value at a given position :code:`xt` with a :code:`PolyhedralFunction` :code:`Vt` ::
 
     vx = get_bellman_value(model, param, t, Vt, xt)
-    
+
 This is a lower bound of the true value.
 
 Get optimal control at a given point
@@ -57,7 +57,7 @@ SDDP hotstart
 
 If cuts are already available, we can hotstart SDDP while overloading the function :code:`solve_SDDP`::
 
-    V, pbs = solve_SDDP(model, params, 0, V)
+    V, pbs = solve_SDDP(model, params, V, 0)
 
 
 Cuts pruning

examples/benchmark.jl

@@ -197,19 +197,17 @@ function benchmark_sddp()
     # Launch benchmark
     println("Launch SDDP ...")
     tic()
-    V, pbs = solve_SDDP(model, params, 0)
+    V, pbs = @time solve_SDDP(model, params, 0)
     texec = toq()
     println("Time to solve SDDP: ", texec, "s")
 
     # Test results upon 100 assessment scenarios:
     n_assessments = 100
     aleas = simulate_scenarios(model.noises,
-                              (model.stageNumber,
-                               n_assessments,
-                               model.dimNoises))
+                               n_assessments)
 
     tic()
-    costs_sddp, stocks = forward_simulations(model, params, V, pbs, aleas)
+    costs_sddp, stocks = forward_simulations(model, params, pbs, aleas)
     texec = toq()
     println("Time to perform simulation: ", texec, "s")
 

examples/dam.jl

@@ -164,8 +164,7 @@ function solve_dams(display=0)
     V, pbs = solve_SDDP(model, params, display)
     aleas = simulate_scenarios(model.noises, params.forwardPassNumber)
 
-    costs, stocks = forward_simulations(model, params, V, pbs, aleas)
-
+    costs, stocks = forward_simulations(model, params, pbs, aleas)
     println("SDDP cost: ", costs)
     return stocks
 end