Predictor-Corrector algorithm

.gitignore

@@ -2,4 +2,4 @@
 *.jl.cov
 *.jl.*.cov
 *.jl.mem
-Manifest.toml
+Manifest.toml

README.md

@@ -66,21 +66,21 @@ When using Tulip through JuMP/MOI, parameters can be set either through MOI's ge
     ```julia
     jump_model = JuMP.Model(Tulip.Optimizer)
 
-    JuMP.set_optimizer_attribute(jump_model, "BarrierIterationsLimit", 200)
+    JuMP.set_optimizer_attribute(jump_model, "IPM_IterationsLimit", 200)
     ```
 
 * Through MOI
     ```julia
     moi_model = Tulip.Optimizer{Float64}()
 
-    MOI.set(moi_model, MOI.RawParameter("BarrierIterationsLimit"), 200)
+    MOI.set(moi_model, MOI.RawParameter("IPM_IterationsLimit"), 200)
     ```
 
 * Through Tulip's API
     ```julia
     model = Tulip.Model{Float64}()
 
-    Tulip.set_parameter(model, "BarrierIterationsLimit", 200)
+    Tulip.set_parameter(model, "IPM_IterationsLimit", 200)
     ```
 
 ### Parameters description

docs/make.jl

@@ -11,13 +11,19 @@ makedocs(
         ],
         "User manual" => Any[
             "Problem formulation" => "manual/formulation.md",
-            "Solving linear systems" => "manual/linear_systems.md"
+            "Solving linear systems" => "manual/linear_systems.md",
+            "Algorithms" => Any[
+                "Homogeneous Self-Dual" => "manual/IPM/HSD.md",
+                "Predictor-Corrector" => "manual/IPM/MPC.md"
+            ],
+            "Setting options" => "manual/options.md"
         ],
         "Reference" => Any[
+            "Presolve" => "reference/Presolve/presolve.md",
+            "KKT solvers" => "reference/KKT/kkt_solvers.md",
             "Julia API" => "reference/API.md",
             "Attributes" => "reference/attributes.md",
-            "Parameters" => "reference/parameters.md",
-            "KKT solvers" => "reference/kkt_solvers.md"
+            "Options" => "reference/options.md"
         ],
     ]
 )

docs/src/manual/IPM/HSD.md

@@ -0,0 +1,10 @@
+# Homogeneous Self-Dual algorithm
+
+```@docs
+Tulip.HSD
+```
+
+## References
+
+* Anjos, M.F.; Lodi, A.; Tanneau, M.
+    [Design and implementation of a modular interior-point solver for linear optimization](https://arxiv.org/abs/2006.08814)

docs/src/manual/IPM/MPC.md

@@ -0,0 +1,11 @@
+# Predictor-Corrector algorithm
+
+```@docs
+Tulip.MPC
+```
+
+## References
+
+* Mehrotra, S.
+    [On the Implementation of a Primal-Dual Interior Point Method](https://doi.org/10.1137/0802028)
+    SIAM Journal on Optimization, 1992, 2, 575-601

docs/src/manual/options.md

@@ -0,0 +1,17 @@
+```@meta
+CurrentModule = Tulip
+```
+
+# Options management
+
+!!! info
+    This part of the documentation is under construction
+
+See [Options reference](@ref) for a list of all available options and their signification.
+
+## Handling options within JuMP
+
+## Handling options within MOI
+
+## Handling options directly
+

docs/src/reference/kkt_solvers.md → docs/src/reference/KKT/kkt_solvers.md

@@ -26,19 +26,7 @@ solve!
 ### Choosing between linear solvers
 
 ```@docs
-SolverOptions
-```
-
-```@meta
-CurrentModule = Tulip
-```
-
-```@docs
-TLA.MatrixOptions
-```
-
-```@meta
-CurrentModule = Tulip.KKT
+KKTOptions
 ```
 
 ## Dense/LAPACK

docs/src/reference/options.md

@@ -0,0 +1,75 @@
+```@meta
+CurrentModule = Tulip
+```
+
+# Options reference
+
+Parameters can be queried and set through the [`get_parameter`](@ref) and [`set_parameter`](@ref) functions.
+
+In all that follows, ``\epsilon`` refers to the numerical precision, which is given by `eps(Tv)` where `Tv` is the arithmetic of the current model.
+For instance, in double-precision arithmetic, i.e., `Tv=Float64`, we have ``\epsilon \simeq 10^{-16}``.
+
+```@docs
+Factory
+```
+
+## Presolve
+
+These parameters control the execution of the presolve phase.
+They should be called as `"Presolve_<Param>"`.
+
+
+## Linear Algebra
+
+These parameters control the linear algebra implementation
+
+| Parameter | Description | Default |
+|:----------|:------------|:--------|
+| `MatrixFactory` | See [`Factory`](@ref) | `Factory(SparseMatrixCSC)`
+
+
+## KKT solvers
+
+| Parameter | Description | Default |
+|:----------|:------------|:--------|
+| `Factory` | See [`Factory`](@ref) | [`KKT.CholmodSQD`](@ref) for `Float64`, [`KKT.LDLFactSQD`](@ref) otherwise |
+
+## Interior-Point
+
+### Tolerances
+
+Numerical tolerances for the interior-point algorithm.
+
+| Parameter | Description | Default |
+|:----------|:------------|:--------|
+| `TolerancePFeas` | Primal feasibility tolerance | ``\sqrt{\epsilon}``
+| `ToleranceDFeas` | Dual feasibility tolerance | ``\sqrt{\epsilon}``
+| `ToleranceRGap`  | Relative optimality gap tolerance | ``\sqrt{\epsilon}``
+| `ToleranceIFeas` | Infeasibility tolerance | ``\sqrt{\epsilon}``
+
+### Algorithmic parameters
+
+| Parameter | Description | Default |
+|:----------|:------------|:--------|
+| `BarrierAlgorithm` | Interior-point algorithm | `1` |
+| `CorrectionLimit` | Maximum number of additional centrality corrections | `5` |
+| `StepDampFactor` | Step | `0.9995` |
+| `GammaMin` | Minimum value of ``\gamma`` for computing correctors | `0.1`
+| `CentralityOutlierThreshold` | Relative threshold for computing extra centrality corrections | `0.1`
+| `PRegMin` | Minimum value of primal regularization | ``\sqrt{\epsilon}`` |
+| `DRegMin` | Minimum value of dual regularization | ``\sqrt{\epsilon}``
+
+### Stopping criterion
+
+| Parameter | Description | Default |
+|:----------|:------------|:--------|
+| `IterationsLimit` | Maximum number of barrier iterations | `100` |
+| `TimeLimit` | Time limit, in seconds | `Inf` |
+
+## Others
+
+| Parameter | Description | Default |
+|:----------|:------------|:--------|
+| `OutputLevel` | Controls the solver's output | `0` |
+| `Threads` | Maximum number of threads | `1` |
+| `Presolve` | Presolve (no presolve if set to ≤ 0) | `1` |

docs/src/tutorials/lp_example.md

@@ -45,7 +45,7 @@ lp = Model(Tulip.Optimizer)
 
 # Set some parameters
 set_optimizer_attribute(lp, "OutputLevel", 0)  # disable output
-set_optimizer_attribute(lp, "Presolve", 0)     # disable presolve
+set_optimizer_attribute(lp, "Presolve_Level", 0)     # disable presolve
 
 # Solve the problem
 optimize!(lp)
@@ -114,7 +114,7 @@ MOI.set(lp, MOI.ObjectiveSense(), MOI.MIN_SENSE)
 
 # Set some parameters
 MOI.set(lp, MOI.Silent(), true)               # disable output
-MOI.set(lp, MOI.RawParameter("Presolve"), 0)  # disable presolve
+MOI.set(lp, MOI.RawParameter("Presolve_Level"), 0)  # disable presolve
 
 # Solve the problem
 MOI.optimize!(lp)
@@ -169,7 +169,7 @@ row3 = Tulip.add_constraint!(pb, [x, y], [1.0,  2.0], -Inf, 7.0, "row3")
 
 # Set some parameters
 Tulip.set_parameter(lp, "OutputLevel", 0)  # disable output
-Tulip.set_parameter(lp, "Presolve", 0)     # disable presolve
+Tulip.set_parameter(lp, "Presolve_Level", 0)     # disable presolve
 
 # Solve the problem
 Tulip.optimize!(lp)

examples/dat/lpex_freevars.mps

@@ -0,0 +1,26 @@
+NAME          LP_FREE_VARS
+
+*   Problem:
+*   min     x1   + x2 + x3
+*   s.t.    2 x1 + x2 >= 2
+*           x1 + 2 x2 >= 2
+*           x1 + x2 + x3 >= 0
+
+ROWS     
+ G  ROW1
+ G  ROW2
+ G  ROW3
+ N  COST
+COLUMNS
+    X1        ROW1                2.   ROW2                1.
+    X1        COST                1.   ROW3                1.
+    X2        ROW1                1.   ROW2                2.
+    X2        COST                1.   ROW3                1.
+    X3        ROW3                1.   COST                1.
+RHS
+    B         ROW1                2.   ROW2                2.
+BOUNDS
+ FR BND1      X1
+ FR BND1      X2
+ FR BND1      X3
+ENDATA

examples/freevars.jl

@@ -9,7 +9,8 @@ INSTANCE_DIR = joinpath(@__DIR__, "dat")
 
 function ex_freevars(::Type{Tv};
     atol::Tv = 100 * sqrt(eps(Tv)),
-    rtol::Tv = 100 * sqrt(eps(Tv))
+    rtol::Tv = 100 * sqrt(eps(Tv)),
+    kwargs...
 ) where{Tv}
     #=
     Example with free variables
@@ -21,6 +22,10 @@ function ex_freevars(::Type{Tv};
     =#
     m = TLP.Model{Tv}()
     m.params.OutputLevel = 1
+    # Set optional parameters
+    for (k, val) in kwargs
+        TLP.set_parameter(m, String(k), val)
+    end
 
     # Read problem and solve
     TLP.load_problem!(m, joinpath(INSTANCE_DIR, "lpex_freevars.mps"))

examples/infeasible.jl

@@ -9,7 +9,8 @@ INSTANCE_DIR = joinpath(@__DIR__, "dat")
 
 function ex_infeasible(::Type{Tv};
     atol::Tv = 100 * sqrt(eps(Tv)),
-    rtol::Tv = 100 * sqrt(eps(Tv))
+    rtol::Tv = 100 * sqrt(eps(Tv)),
+    kwargs...
 ) where{Tv}
     #=
     Infeasible example
@@ -22,6 +23,10 @@ function ex_infeasible(::Type{Tv};
     =#
     m = TLP.Model{Tv}()
     m.params.OutputLevel = 1
+    # Set optional parameters
+    for (k, val) in kwargs
+        TLP.set_parameter(m, String(k), val)
+    end
 
     # Read problem from .mps file and solve    
     TLP.load_problem!(m, joinpath(INSTANCE_DIR, "lpex_inf.mps"))

examples/optimal.jl

@@ -9,7 +9,8 @@ INSTANCE_DIR = joinpath(@__DIR__, "dat")
 
 function ex_optimal(::Type{Tv};
     atol::Tv = 100 * sqrt(eps(Tv)),
-    rtol::Tv = 100 * sqrt(eps(Tv))
+    rtol::Tv = 100 * sqrt(eps(Tv)),
+    kwargs...
 ) where{Tv}
 
     #=
@@ -23,6 +24,10 @@ function ex_optimal(::Type{Tv};
     =#
     m = TLP.Model{Tv}()
     m.params.OutputLevel = 1
+    # Set optional parameters
+    for (k, val) in kwargs
+        TLP.set_parameter(m, String(k), val)
+    end
 
     # Read problem and solve
     TLP.load_problem!(m, joinpath(INSTANCE_DIR, "lpex_opt.mps"))

examples/unbounded.jl

@@ -9,7 +9,8 @@ INSTANCE_DIR = joinpath(@__DIR__, "dat")
 
 function ex_unbounded(::Type{Tv};
     atol::Tv = 100 * sqrt(eps(Tv)),
-    rtol::Tv = 100 * sqrt(eps(Tv))
+    rtol::Tv = 100 * sqrt(eps(Tv)),
+    kwargs...
 ) where{Tv}
     #=
     Unbounded example
@@ -20,6 +21,10 @@ function ex_unbounded(::Type{Tv};
     =#
     m = TLP.Model{Tv}()
     m.params.OutputLevel = 1
+    # Set optional parameters
+    for (k, val) in kwargs
+        TLP.set_parameter(m, String(k), val)
+    end
 
     # Read problem from .mps file and solve    
     TLP.load_problem!(m, joinpath(INSTANCE_DIR, "lpex_ubd.mps"))