WIP: MOI

src/CPLEX.jl

@@ -85,28 +85,35 @@ module CPLEX
     include("cpx_env.jl")
     v = version()
     if startswith(v,"12.6")
-        include("full_defines_126.jl")
-        include("cpx_params_126.jl")
+        include(joinpath("cpx_defines", "full_defines_126.jl"))
+        include(joinpath("cpx_params", "cpx_params_126.jl"))
     elseif startswith(v,"12.7.1")
-        include("full_defines_1271.jl")
-        include("cpx_params_1271.jl")
+        include(joinpath("cpx_defines", "full_defines_1271.jl"))
+        include(joinpath("cpx_params", "cpx_params_1271.jl"))
     elseif startswith(v,"12.7")
-        include("full_defines_127.jl")
-        include("cpx_params_127.jl")
+        include(joinpath("cpx_defines", "full_defines_127.jl"))
+        include(joinpath("cpx_params", "cpx_params_127.jl"))
     else
         error("Unsupported CPLEX version $v. Only 12.6 and 12.7 are currently supported.")
     end
+
     include("cpx_model.jl")
     include("cpx_params.jl")
-    include("cpx_vars.jl")
-    include("cpx_constrs.jl")
-    include("cpx_quad.jl")
+    # include("cpx_vars.jl")
+    # include("cpx_constrs.jl")
+    # include("cpx_quad.jl")
+    # include("cpx_solve.jl")
+    # include("cpx_callbacks.jl")
+    # include("cpx_highlevel.jl")
+
+
+    include("cpx_variables.jl")
+    include("cpx_constraints.jl")
+    include("cpx_objective.jl")
     include("cpx_solve.jl")
-    include("cpx_callbacks.jl")
-    include("cpx_highlevel.jl")
 
     # include("CplexSolverInterface.jl")
-    include("MOI/MathOptInterface.jl")
+    include("MathOptInterface.jl")
     # These are undocumented JuMP extensions for CPLEX which
     # will need to be hosted in a separate package for Julia 0.6 and later.
     if isdir(Pkg.dir("JuMP")) && VERSION < v"0.6-"

src/MOI/MathOptInterface.jl → src/MathOptInterface.jl

@@ -12,6 +12,7 @@ function CplexSolver(;mipstart_effortlevel::Cint = CPX_MIPSTART_AUTO, options...
     CplexSolver(mipstart_effortlevel, options)
 end
 
+MOI.getattribute(s::CplexSolver, ::MOI.SupportsDuals) = false
 
 const Linear = MOI.ScalarAffineFunction{Float64}
 const LE = MOI.LessThan{Float64}
@@ -71,11 +72,16 @@ ConstraintMapping() = ConstraintMapping(
 
 mutable struct CplexSolverInstance <: MOI.AbstractSolverInstance
     inner::Model
+
     last_variable_reference::UInt64
     variable_mapping::Dict{MOI.VariableReference, Int}
+    variable_references::Vector{MOI.VariableReference}
+    primal_solution::Vector{Float64}
 
     last_constraint_reference::UInt64
     constraint_mapping::ConstraintMapping
+
+    objective_constant::Float64
 end
 
 function MOI.SolverInstance(s::CplexSolver)
@@ -88,13 +94,16 @@ function MOI.SolverInstance(s::CplexSolver)
         Model(env),
         0,
         Dict{MOI.VariableReference, Int}(),
+        MOI.VariableReference[],
+        Float64[],
         0,
-        ConstraintMapping()
+        ConstraintMapping(),
+        0.0
     )
 end
+include(joinpath("cpx_status", "status_codes.jl"))
 
-include("macros_cpx.jl")
-include("variables.jl")
-include("constraints.jl")
-include("objective.jl")
-include("solve.jl")
+include("moi_variables.jl")
+include("moi_constraints.jl")
+include("moi_objective.jl")
+include("moi_solve.jl")

src/cpx_common.jl

@@ -1,27 +1,39 @@
 # makes calling C functions a bit easier
+"""
+    @cpx_ccall(func, args...)
+"""
 macro cpx_ccall(func, args...)
     f = "CPX$(func)"
     args = map(esc,args)
     if is_unix()
-        return quote
-            ccall(($f,libcplex), $(args...))
-        end
-    end
-    if is_windows()
+        return quote stat = ccall(($f,libcplex), $(args...)) end
+    elseif is_windows()
         if VERSION < v"0.6.0-dev.1512" # probably julia PR #15850
-            return quote
-                ccall(($f,libcplex), stdcall, $(args...))
-            end
+            return quote stat = ccall(($f,libcplex), stdcall, $(args...)) end
         else
-            return quote
-                ccall(($f,libcplex), $(esc(:stdcall)), $(args...))
-            end
+            return quote stat = ccall(($f,libcplex), $(esc(:stdcall)), $(args...)) end
+        end
+    else
+        error("Unknown platform.")
+    end
+end
+
+"""
+    @cpx_ccall_error(env, func, args...)
+
+Throws CplexError if return code is not 0
+"""
+macro cpx_ccall_error(env, func, args...)
+    args = map(esc,args)
+    quote
+        stat = $(Expr(:macrocall, Symbol("@cpx_ccall"), esc(func), args...))
+        if stat != 0
+           throw(CplexError($(esc(env)), stat))
         end
     end
 end
 
 macro cpx_ccall_intercept(model, func, args...)
-    f = "CPX$(func)"
     args = map(esc,args)
     quote
         ccall(:jl_exit_on_sigint, Void, (Cint,), convert(Cint,0))
@@ -43,41 +55,3 @@ macro cpx_ccall_intercept(model, func, args...)
         ret
     end
 end
-
-const GChars = Union{Cchar, Char}
-const IVec = Vector{Cint}
-const FVec = Vector{Cdouble}
-const CVec = Vector{Cchar}
-const CoeffMat = Union{Matrix{Cdouble}, SparseMatrixCSC{Cdouble}}
-@compat Bounds{T<:Real} = Union{T, Vector{T}}
-
-const GCharOrVec = Union{Cchar, Char, Vector{Cchar}, Vector{Char}}
-
-# empty vector & matrix (for the purpose of supplying default arguments)
-const emptyfvec = Vector{Float64}(0)
-const emptyfmat = Matrix{Float64}(0, 0)
-
-cchar(c::Cchar) = c
-cchar(c::Char) = convert(Cchar, c)
-
-ivec(v::IVec) = v
-fvec(v::FVec) = v
-cvec(v::CVec) = v
-
-ivec(v::Vector) = convert(IVec, v)
-fvec(v::Vector) = convert(FVec, v)
-cvec(v::Vector) = convert(CVec, v)
-
-# cvecx(v, n) and fvecx(v, n)
-# converts v into a vector of Cchar or Float64 of length n,
-# where v can be either a scalar or a vector of length n.
-
-_chklen(v, n::Integer) = (length(v) == n || error("Inconsistent argument dimensions."))
-
-cvecx(c::GChars, n::Integer) = fill(cchar(c), n)
-cvecx(c::Vector{Cchar}, n::Integer) = (_chklen(c, n); c)
-cvecx(c::Vector{Char}, n::Integer) = (_chklen(c, n); convert(Vector{Cchar}, c))
-
-fvecx(v::Real, n::Integer) = fill(Float64(v), n)
-fvecx(v::Vector{Float64}, n::Integer) = (_chklen(v, n); v)
-fvecx{T<:Real}(v::Vector{T}, n::Integer) = (_chklen(v, n); convert(Vector{Float64}, v))

src/cpx_constraints.jl

@@ -0,0 +1,55 @@
+function cpx_add_constraint!(model::Model, cols::Vector{Int}, coefficients::Vector{Float64}, sense::Cchar, rhs::Float64)
+    @assert length(cols) == length(coefficients)
+    nnz = Cint(length(cols))
+    @cpx_ccall(addrows, Cint, (
+        Ptr{Void},        # environment
+        Ptr{Void},        # problem
+        Cint,             # num new cols
+        Cint,             # num new rows
+        Cint,             # num non-zeros
+        Ptr{Cdouble},     # rhs
+        Ptr{Cchar},       # sense
+        Ptr{Cint},        # matrix start
+        Ptr{Cint},        # matrix index
+        Ptr{Cdouble},     # matrix values
+        Ptr{Ptr{Cchar}},  # col names
+        Ptr{Ptr{Cchar}}   # row names
+        ),
+        model.env.ptr, model.lp, 0, Cint(1), nnz, [rhs], [sense], [Cint(0)], Cint.(cols-1), coefficients, C_NULL, C_NULL)
+end
+
+function cpx_number_constraints(model::Model)
+    ncons = @cpx_ccall(getnumrows, Cint, (
+                       Ptr{Void},
+                       Ptr{Void}
+                       ),
+                       model.env.ptr, model.lp)
+    return ncons
+end
+
+function get_rhs(model::Model)
+    ncons = cpx_number_constraints(model)
+    rhs = Vector{Cdouble}(ncons)
+    @cpx_ccall_error(model.env, getrhs, Cint, (
+                      Ptr{Void},
+                      Ptr{Void},
+                      Ptr{Cdouble},
+                      Cint,
+                      Cint
+                      ),
+                      model.env.ptr, model.lp, rhs, 0, ncons-1)
+    return rhs
+end
+
+function cpx_get_rhs(model::Model, row::Int)
+    rhs = Vector{Cdouble}(1)
+    @cpx_ccall_error(model.env, getrhs, Cint, (
+                      Ptr{Void},
+                      Ptr{Void},
+                      Ptr{Cdouble},
+                      Cint,
+                      Cint
+                      ),
+                      model.env.ptr, model.lp, rhs, Cint(row-1), Cint(row-1))
+    return rhs[1]
+end

src/cpx_env.jl

@@ -1,3 +1,11 @@
+function  cpx_finalizer(env)
+    if env.num_models == 0
+        close_CPLEX(env)
+    else
+        env.finalize_called = true
+    end
+end
+
 type Env
     ptr::Ptr{Void}
     num_models::Int
@@ -10,13 +18,7 @@ type Env
           error("CPLEX: Error creating environment")
       end
       env = new(tmp, 0, false)
-      finalizer(env, env -> begin
-                                if env.num_models == 0
-                                    close_CPLEX(env)
-                                else
-                                    env.finalize_called = true
-                                end
-                            end)
+      finalizer(env, cpx_finalizer)
       env
     end
 end