Merge pull request #2 from jump-dev/bl/clean_up

Implement MOI interface for LP forms

Author: blegat

.travis.yml

@@ -1,11 +1,11 @@
 ## Documentation: http://docs.travis-ci.com/user/languages/julia/
 language: julia
+codecov: true
 os:
   - linux
 julia:
-  - 0.6
-  - 0.7
   - 1.0
+  - 1
   - nightly
 matrix:
   allow_failures:
@@ -23,7 +23,3 @@ notifications:
     on_success: change  # options: [always|never|change] default: always
     on_failure: always  # options: [always|never|change] default: always
     on_start: never     # options: [always|never|change] default: always
-
-after_success:
- - julia -e 'if VERSION >= v"0.7-"; using Pkg; else; cd(Pkg.dir("MatrixOptInterface")); end; Pkg.add("Coverage"); using Coverage; Codecov.submit(process_folder())'
- 

Project.toml

@@ -6,6 +6,7 @@ version = "0.1.0"
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee"
+SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [compat]

README.md

@@ -1,2 +1,89 @@
 # MatrixOptInterface.jl
-An interface for matrix form optimization problems
+
+**This package is this in early development, feedback is welcome!**
+
+An interface for optimization problems in matrix forms.
+Several matrix forms are represented in subtypes of
+[`MathOptInterface (MOI)`](https://github.com/jump-dev/MathOptInterface.jl)
+models.
+As they implement the MOI API, they can be copied directly to an MOI or JuMP
+model.
+
+Here is a simple example copying a linear program represented in its standard
+form into JuMP:
+```julia
+import MatrixOptInterface
+const MatOI = MatrixOptInterface
+lp = MatOI.LPStandardForm{Float64, Matrix{Float64}}(MOI.MAX_SENSE, [1.0, 0.0], [1.0 1.0], [1.0])
+
+using JuMP
+model = Model()
+MOI.copy_to(model, lp)
+```
+
+Giving some arbitrary names to the variables for pretty printing:
+```julia
+set_name.(all_variables(model), "x" .* string.(1:2))
+print(model)
+```
+we get the following output:
+```
+Max x1
+Subject to
+ x1 + x2 = 1.0
+ [x1, x2] ∈ MathOptInterface.Nonnegatives(2)
+```
+
+The LP standard form is the the only one implemented in this package.
+The 4 different available forms of linear programs are given below.
+In each form, `sense` is a `MOI.OptimizationSense` so its values
+are either `MOI.FEASIBILITY_SENSE`, `MOI.MAX_SENSE` or `MOI.MIN_SENSE`.
+
+An LP standard form with `LPStandardForm(sense, c, A, b)`:
+```
+sense ⟨c, x⟩
+s.t.
+Ax == b
+ x >= 0
+```
+
+An LP geometric form with `LPGeometricForm(sense, c, A, b)`:
+```
+sense ⟨c, x⟩
+s.t.
+Ax <= b
+```
+
+A generic LP form with `LPForm(sense, c, A, c_lb, c_ub, v_lb, v_ub)`:
+```
+sense ⟨c, x⟩
+s.t.
+c_lb <= Ax <= c_ub
+v_lb <=  x <= v_ub
+```
+
+An LP Solver form with `LPSolverForm(sense, c, A, b, senses, v_lb, v_ub)`:
+```
+sense ⟨c, x⟩
+s.t.
+Ax senses b
+v_lb <=  x <= v_ub
+```
+where `senses` is a vector whose `i`th entry is either
+* `MatOI.EQUAL_TO` if `(Ax)_i = b_i`,
+* `MatOI.LESS_THAN` if `(Ax)_i <= b_i`,
+* `MatOI.GREATER_THAN` if `(Ax)_i >= b_i`.
+
+## Transition from linprog
+
+If you are used to [`MathProgBase`](https://github.com/JuliaOpt/MathProgBase.jl)'s or MATLAB's `linprog` function, this package provides an easy transition.
+The package does not provide a one-shot function that takes the form as input are returns the solution and status as
+in general, solvers may have multiple solutions to report and the status cannot be summarized in a single value.
+`MathOptInterface` embraces this complexity and allows to retrieve multiple solutions,
+has 4 different solver-independent statuses (`MOI.TerminationStatus`, `MOI.PrimalStatus`, `MOI.DualStatus` and `MOI.RawStatusString`) and also
+allows solvers to provide solver independent statuses.
+For these reasons, there is no `linprog` functions covering all use cases but using this packages one covering your use cases can be implemented in just a few lines:
+1) Create the appropriate structure from the matrix data, e.g. `LPForm`, `LPSolverForm`, ...
+2) Copy it to a JuMP model or MOI optimizer.
+3) Call `JuMP.optimize!` or `MOI.optimize!`.
+4) Retrieve and return solutions and statuses.

src/MatrixOptInterface.jl

@@ -1,17 +1,63 @@
 module MatrixOptInterface
 
-using LinearAlgebra
+using LinearAlgebra, SparseArrays
 using MathOptInterface
 const MOI = MathOptInterface
 const MOIU = MathOptInterface.Utilities
 
 # export MatrixOptimizer
 
-@enum ConstraintSense EQUAL_TO GREATER_THAN LESS_THAN
+@enum ConstraintSense EQUAL_TO GREATER_THAN LESS_THAN INTERVAL
+_sense(::Type{<:MOI.EqualTo}) = EQUAL_TO
+_sense(::Type{<:MOI.LessThan}) = LESS_THAN
+_sense(::Type{<:MOI.GreaterThan}) = GREATER_THAN
+_sense(::Type{<:MOI.Interval}) = INTERVAL
+
+_no_upper(bound) = bound != typemax(bound)
+_no_lower(bound) = bound != typemin(bound)
+
+function _bound_sense(lb::T, ub::T) where T
+    if _no_upper(ub)
+        if _no_lower(lb)
+            if lb == ub
+                return EQUAL_TO
+            else
+                return INTERVAL
+            end
+        else
+            return LESS_THAN
+        end
+    else
+        if _no_lower(lb)
+            return GREATER_THAN
+        else
+            return
+        end
+    end
+end
+function _bound_set(lb::T, ub::T) where T
+    if _no_upper(ub)
+        if _no_lower(lb)
+            if ub == lb
+                return MOI.EqualTo(lb)
+            else
+                return MOI.Interval(lb, ub)
+            end
+        else
+            return MOI.LessThan(ub)
+        end
+    else
+        if _no_lower(lb)
+            return MOI.GreaterThan(lb)
+        else
+            return
+        end
+    end
+end
 
 @enum VariableType CONTINUOUS INTEGER BINARY
 
 include("matrix_input.jl")
-include("allocate_load.jl")
+include("change_form.jl")
 
-end
+end