mipper 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad701722ba6d2ee732f074d86dba521d8f725d46
-  data.tar.gz: e00ab9b7c632eb8f8eba0164c0c8c0ed68d5c5bb
+  metadata.gz: 99f7bd81a866c8127ba5527dd8eb2107fc3c3ee1
+  data.tar.gz: 6b94eefa7fb9ab14b6400963f7975fca4b40b538
 SHA512:
-  metadata.gz: 09bb2783869873c9d04a20592b1e3d69856dd09fc032546d85bc8405f8931b953eaba2152e3e2c726fe387727bcc33428055c64399f187851a0aaa6964ed7b30
-  data.tar.gz: a7ecfb338d2bc14bf44586217d0cd059c212ed1ee0950b1c17d40cb4dbda6d7d1cf4756087094e99ec167aed8984a02e259de5d1f3b6016029b18913a8e3c671
+  metadata.gz: f7c81f9e6743229544bd55ba20796c39a80aa35ba63cea211722ab2d56056dd9cc86314d685cd0ef746daca4ebe03da8b9b92da3925bc76e5dc21ee1f30f00b6
+  data.tar.gz: 1c43605bf6efdb20bd227f569b385c89bc25567416e5511d28125d81ac081884c93d754fe4e6667631b6be31440c836384b808e72503203980628dff1140e700

data/lib/mipper.rb

@@ -3,6 +3,7 @@ require_relative 'mipper/util'
 require_relative 'mipper/constraint'
 require_relative 'mipper/expression'
 require_relative 'mipper/model'
+require_relative 'mipper/solution'
 require_relative 'mipper/variable'
 
 require_relative 'mipper/cbc'

data/lib/mipper/cbc/model.rb

@@ -1,6 +1,7 @@
 require 'zlib'
 
 module MIPPeR
+  # A linear programming model using the COIN-OR solver
   class CbcModel < Model
     attr_reader :ptr
 
@@ -11,18 +12,31 @@ module MIPPeR
       @constr_count = 0
 
       # Construct a new model
-      @ptr = FFI::AutoPointer.new Cbc.Cbc_newModel,
-                                  Cbc.method(:Cbc_deleteModel)
-      Cbc.Cbc_setParameter @ptr, 'logLevel', '0'
+      @ptr = new_model
     end
 
     # Write the model to a file in MPS format
     def write_mps(filename)
-      Cbc.Cbc_writeMps @ptr, File.join(File.dirname(filename),
-                                       File.basename(filename, '.mps'))
+      # Make a new model and ensure everything is added
+      old_ptr = @ptr
+      @ptr = new_model
+      parent_update
+
+      Cbc.Cbc_writeMps @ptr, filename.chomp('.mps')
       contents = Zlib::GzipReader.open(filename + '.gz').read
       File.delete(filename + '.gz')
       File.open(filename, 'w').write contents
+
+      # Reset to the original model
+      @ptr = old_ptr
+      reset_model
+    end
+
+    alias_method :parent_update, :update
+
+    # Avoid doing anything here. Updating multiple times will
+    # break the model so we defer to #solve.
+    def update
     end
 
     # Set the sense of the model
@@ -35,40 +49,24 @@ module MIPPeR
     # Optimize the model
     def optimize
       # Ensure pending variables and constraints are added
-      update
+      parent_update
 
       # Run the solver and save the status for later
       Cbc.Cbc_solve @ptr
       fail if Cbc.Cbc_status(@ptr) != 0
 
-      # Check and store the model status
-      if Cbc.Cbc_isProvenOptimal(@ptr) == 1
-        @status = :optimized
-      elsif Cbc.Cbc_isProvenInfeasible(@ptr) == 1 or
-            Cbc.Cbc_isContinuousUnbounded(@ptr) == 1
-        @status = :invalid
-      else
-        @status = :unknown
-      end
-    end
-
-    # Get the status of the model
-    def status
-      @status
-    end
+      save_solution
 
-    # The value of the objective function
-    def objective_value
-      Cbc.Cbc_getObjValue @ptr
+      @ptr = new_model
+      reset_model
     end
 
-    # Get the value of a variable from the model
-    def variable_value(var)
-      dblptr = Cbc.Cbc_getColSolution @ptr
-      dblptr.read_array_of_double(@variables.length)[var.index]
-    end
+    # Set the bounds of a variable in the model
+    def set_variable_bounds(var_index, lb, ub, force = false)
+      # This is a bit of a hack so that we don't try to set
+      # the variable bounds before they get added to the model
+      return unless force
 
-    def set_variable_bounds(var_index, lb, ub)
       Cbc.Cbc_setColLower @ptr, var_index, lb
       Cbc.Cbc_setColUpper @ptr, var_index, ub
     end
@@ -87,11 +85,40 @@ module MIPPeR
 
     # Add multiple constraints at once
     def add_constraints(constrs)
-      # Store the index which will be used for each constraint
+      start, index, value = build_constraint_matrix constrs
+      start_buffer = build_pointer_array start, :int
+      index_buffer = build_pointer_array index, :int
+      value_buffer = build_pointer_array value, :double
+
+      Cbc.Cbc_loadProblem @ptr, @variables.length, constrs.length,
+                          start_buffer, index_buffer, value_buffer,
+                          nil, nil, nil, nil, nil
+
+      store_model constrs, @variables
+    end
+
+    private
+
+    # Construct a new model object
+    def new_model
+      ptr = FFI::AutoPointer.new Cbc.Cbc_newModel,
+                                 Cbc.method(:Cbc_deleteModel)
+      Cbc.Cbc_setParameter ptr, 'logLevel', '0'
+
+      ptr
+    end
+
+    # Store the index which will be used for each constraint
+    def store_constraint_indexes(constrs)
       constrs.each do |constr|
         constr.instance_variable_set :@index, @constr_count
         @constr_count += 1
       end
+    end
+
+    # Build a constraint matrix for the currently existing variables
+    def build_constraint_matrix(constrs)
+      store_constraint_indexes constrs
 
       # Construct a matrix of non-zero values in CSC format
       start = []
@@ -110,30 +137,60 @@ module MIPPeR
       end
       start << col_start
 
-      start_buffer = FFI::MemoryPointer.new :int, start.length
-      start_buffer.write_array_of_int start
-      index_buffer = FFI::MemoryPointer.new :int, index.length
-      index_buffer.write_array_of_int index
-      value_buffer = FFI::MemoryPointer.new :double, value.length
-      value_buffer.write_array_of_double value
-
-      Cbc.Cbc_loadProblem @ptr, @variables.length, constrs.length,
-                          start_buffer, index_buffer, value_buffer,
-                          nil, nil, nil, nil, nil
+      [start, index, value]
+    end
 
+    # Store all data for the model
+    def store_model(constrs, vars)
+      # Store all constraints
       constrs.each do |constr|
         store_constraint constr
         @constraints << constr
       end
 
       # We store variables now since they didn't exist earlier
-      @variables.each_with_index do |var, i|
+      vars.each_with_index do |var, i|
         var.instance_variable_set(:@index, i)
         store_variable var
       end
     end
 
-    private
+    # Save the solution to the model for access later
+    def save_solution
+      # Check and store the model status
+      if Cbc.Cbc_isProvenOptimal(@ptr) == 1
+        status = :optimized
+      elsif Cbc.Cbc_isProvenInfeasible(@ptr) == 1 ||
+            Cbc.Cbc_isContinuousUnbounded(@ptr) == 1
+        status = :invalid
+      else
+        status = :unknown
+      end
+
+      if status == :optimized
+        objective_value = Cbc.Cbc_getObjValue @ptr
+        dblptr = Cbc.Cbc_getColSolution @ptr
+        values = dblptr.read_array_of_double(@variables.length)
+        variable_values = Hash[@variables.map do |var|
+          [var.name, values[var.index]]
+        end]
+      else
+        objective_value = nil
+        variable_values = {}
+      end
+
+      @solution = Solution.new status, objective_value, variable_values
+    end
+
+    # Reset the internal state of the model so we can reuse it
+    def reset_model
+      @var_count = 0
+      @constr_count = 0
+      @pending_variables = @variables
+      @pending_constraints = @constraints
+      @variables = []
+      @constraints = []
+    end
 
     # Save the constraint to the model and update the constraint pointers
     def store_constraint(constr)
@@ -143,17 +200,22 @@ module MIPPeR
 
       # Set constraint properties
       Cbc.Cbc_setRowName(@ptr, index, constr.name) unless constr.name.nil?
+      store_constraint_bounds index, constr.sense, constr.rhs
+    end
 
-      case constr.sense
+    # Store the bounds for a given constraint
+    def store_constraint_bounds(index, sense, rhs)
+      case sense
       when :==
-        lb = ub = constr.rhs
+        lb = ub = rhs
       when :>=
-        lb = constr.rhs
+        lb = rhs
         ub = Float::INFINITY
       when :<=
         lb = -Float::INFINITY
-        ub = constr.rhs
+        ub = rhs
       end
+
       Cbc.Cbc_setRowLower @ptr, index, lb
       Cbc.Cbc_setRowUpper @ptr, index, ub
     end
@@ -165,21 +227,23 @@ module MIPPeR
         var.instance_variable_set(:@lower_bound, 0)
         var.instance_variable_set(:@upper_bound, 1)
       end
+      set_variable_bounds var.index, var.lower_bound, var.upper_bound, true
 
-      Cbc.Cbc_setColLower @ptr, var.index, var.lower_bound
-      Cbc.Cbc_setColUpper @ptr, var.index, var.upper_bound
       Cbc.Cbc_setObjCoeff @ptr, var.index, var.coefficient
+      Cbc.Cbc_setColName(@ptr, var.index, var.name) unless var.name.nil?
+      set_variable_type var.index, var.type
+    end
 
-      case var.type
+    # Set the type of a variable
+    def set_variable_type(index, type)
+      case type
       when :continuous
-        Cbc.Cbc_setContinuous @ptr, var.index
+        Cbc.Cbc_setContinuous @ptr, index
       when :integer, :binary
-        Cbc.Cbc_setInteger @ptr, var.index
+        Cbc.Cbc_setInteger @ptr, index
       else
         fail :type
       end
-
-      Cbc.Cbc_setColName(@ptr, var.index, var.name) unless var.name.nil?
     end
   end
 end

data/lib/mipper/constraint.rb

@@ -13,5 +13,9 @@ module MIPPeR
         var.constraints << self
       end
     end
+
+    def inspect
+      "#{@expression.inspect} #{sense.to_s} #{rhs}"
+    end
   end
 end

data/lib/mipper/glpk/ext/structs.rb

@@ -1,28 +1,29 @@
 module MIPPeR
   module GLPK
+    # Integer optimization control parameters
     class IOCP < FFI::Struct
       layout :msg_lev, :int,
-        :br_tech, :int,
-        :bt_tech, :int,
-        :tol_int, :double,
-        :tol_obj, :double,
-        :tm_lim, :int,
-        :out_frq, :int,
-        :out_dly, :int,
-        :cb_func, callback([:pointer, :pointer], :void),
-        :cb_info, :pointer,
-        :cb_size, :int,
-        :pp_tech, :int,
-        :mip_gap, :double,
-        :mir_cuts, :int,
-        :gmi_cuts, :int,
-        :cov_cuts, :int,
-        :clq_cuts, :int,
-        :presolve, :int,
-        :binarize, :int,
-        :fp_heur, :int,
-        :alien, :int,
-        :foo_bar, [:double, 29]
+             :br_tech, :int,
+             :bt_tech, :int,
+             :tol_int, :double,
+             :tol_obj, :double,
+             :tm_lim, :int,
+             :out_frq, :int,
+             :out_dly, :int,
+             :cb_func, callback([:pointer, :pointer], :void),
+             :cb_info, :pointer,
+             :cb_size, :int,
+             :pp_tech, :int,
+             :mip_gap, :double,
+             :mir_cuts, :int,
+             :gmi_cuts, :int,
+             :cov_cuts, :int,
+             :clq_cuts, :int,
+             :presolve, :int,
+             :binarize, :int,
+             :fp_heur, :int,
+             :alien, :int,
+             :foo_bar, [:double, 29]
     end
   end
 end

data/lib/mipper/glpk/model.rb

@@ -49,29 +49,9 @@ module MIPPeR
       iocp = GLPK::IOCP.new
       GLPK.glp_init_iocp iocp
       iocp[:presolve] = GLPK::GLP_ON
-      @status = GLPK.glp_intopt @ptr, iocp
-    end
-
-    # Get the status of the model
-    def status
-      case @status
-      when 0, GLPK::GLP_EMIPGAP
-        :optimized
-      when GLPK::GLP_EBOUND, GLPK::GLP_EROOT, GLPK::GLP_ENOPFS
-        :invalid
-      else
-        :unknown
-      end
-    end
-
-    # The value of the objective function
-    def objective_value
-      GLPK.glp_mip_obj_val @ptr
-    end
+      status = GLPK.glp_intopt(@ptr, iocp)
 
-    # Get the value of a variable from the model
-    def variable_value(var)
-      GLPK.glp_mip_col_val(@ptr, var.index)
+      save_solution status
     end
 
     def set_variable_bounds(var_index, lb, ub)
@@ -116,12 +96,9 @@ module MIPPeR
         end
       end
 
-      ia_buffer = FFI::MemoryPointer.new :pointer, @ia.length
-      ia_buffer.write_array_of_int @ia
-      ja_buffer = FFI::MemoryPointer.new :pointer, @ja.length
-      ja_buffer.write_array_of_int @ja
-      ar_buffer = FFI::MemoryPointer.new :pointer, @ar.length
-      ar_buffer.write_array_of_double @ar
+      ia_buffer = build_pointer_array @ia, :int
+      ja_buffer = build_pointer_array @ja, :int
+      ar_buffer = build_pointer_array @ar, :double
 
       GLPK.glp_load_matrix(@ptr, @ar.length - 1, ia_buffer, ja_buffer,
                            ar_buffer)
@@ -131,6 +108,31 @@ module MIPPeR
 
     private
 
+    # Save the solution to the model for access later
+    def save_solution(status)
+      status = case status
+               when 0, GLPK::GLP_EMIPGAP
+                 :optimized
+               when GLPK::GLP_EBOUND, GLPK::GLP_EROOT, GLPK::GLP_ENOPFS
+                 :invalid
+               else
+                 :unknown
+               end
+
+      if status == :optimized
+        objective_value = GLPK.glp_mip_obj_val @ptr
+        variable_values = Hash[@variables.map do |var|
+          value = GLPK.glp_mip_col_val(@ptr, var.index)
+          [var.name, value]
+        end]
+      else
+        objective_value = nil
+        variable_values = {}
+      end
+
+      @solution = Solution.new status, objective_value, variable_values
+    end
+
     # Save the constraint to the model and update the constraint pointers
     def store_constraint(constr)
       # Update the constraint to track the index in the model

data/lib/mipper/gurobi/model.rb

@@ -1,4 +1,5 @@
 module MIPPeR
+  # A linear programming model using the Gurobi solver
   class GurobiModel < Model
     attr_reader :ptr, :environment
 
@@ -51,10 +52,25 @@ module MIPPeR
 
       ret = Gurobi.GRBoptimize @ptr
       fail if ret != 0
+
+      save_solution
     end
 
+    # Compute an irreducible inconsistent subsytem for the model
+    def compute_iis
+      ret = Gurobi.GRBcomputeIIS @ptr
+      fail if ret != 0
+    end
+
+    def set_variable_bounds(var_index, lb, ub)
+      set_double_attribute Gurobi::GRB_DBL_ATTR_LB, var_index, lb
+      set_double_attribute Gurobi::GRB_DBL_ATTR_UB, var_index, ub
+    end
+
+    protected
+
     # Get the status of the model
-    def status
+    def gurobi_status
       intptr = FFI::MemoryPointer.new :pointer
       ret = Gurobi.GRBgetintattr @ptr, Gurobi::GRB_INT_ATTR_STATUS, intptr
       fail if ret != 0
@@ -63,59 +79,31 @@ module MIPPeR
       when Gurobi::GRB_OPTIMAL
         :optimized
       when Gurobi::GRB_INFEASIBLE, Gurobi::GRB_INF_OR_UNBD,
-           Gurobi::GRB_UNBOUNDED
+        Gurobi::GRB_UNBOUNDED
         :invalid
       else
         :unknown
       end
     end
 
-    # Compute an irreducible inconsistent subsytem for the model
-    def compute_IIS
-      ret = Gurobi.GRBcomputeIIS @ptr
-      fail if ret != 0
-    end
-
     # The value of the objective function
-    def objective_value
+    def gurobi_objective
       dblptr = FFI::MemoryPointer.new :pointer
       ret = Gurobi.GRBgetdblattr @ptr, Gurobi::GRB_DBL_ATTR_OBJVAL, dblptr
       fail if ret != 0
       dblptr.read_double
     end
 
-    def set_variable_bounds(var_index, lb, ub)
-      set_double_attribute Gurobi::GRB_DBL_ATTR_LB, var_index, lb
-      set_double_attribute Gurobi::GRB_DBL_ATTR_UB, var_index, ub
-    end
-
-    # Get the value of a variable from the model
-    def variable_value(var)
-      dblptr = FFI::MemoryPointer.new :pointer
-      Gurobi.GRBgetdblattrarray @ptr, Gurobi::GRB_DBL_ATTR_X,
-                                var.index, 1, dblptr
-      dblptr.read_array_of_double(1)[0]
-    end
-
-    protected
-
     # Add multiple variables to the model simultaneously
     def add_variables(vars)
-      objective_buffer = FFI::MemoryPointer.new :double, vars.length
-      objective_buffer.write_array_of_double vars.map(&:coefficient)
-
-      lb_buffer = FFI::MemoryPointer.new :double, vars.length
-      lb_buffer.write_array_of_double vars.map(&:lower_bound)
-
-      ub_buffer = FFI::MemoryPointer.new :double, vars.length
-      ub_buffer.write_array_of_double vars.map(&:upper_bound)
-
-      type_buffer = FFI::MemoryPointer.new :char, vars.length
-      type_buffer.write_array_of_char vars.map { |var| gurobi_type(var.type) }
-
-      names = array_to_pointers_to_names vars
-      names_buffer = FFI::MemoryPointer.new :pointer, vars.length
-      names_buffer.write_array_of_pointer names
+      objective_buffer = build_pointer_array vars.map(&:coefficient), :double
+      lb_buffer = build_pointer_array vars.map(&:lower_bound), :double
+      ub_buffer = build_pointer_array vars.map(&:upper_bound), :double
+      type_buffer = build_pointer_array(vars.map do |var|
+        gurobi_type(var.type)
+      end, :char)
+      names_buffer = build_pointer_array array_to_pointers_to_names(vars),
+                                         :pointer
 
       ret = Gurobi.GRBaddvars @ptr, vars.length, 0, nil, nil, nil,
                               objective_buffer, lb_buffer, ub_buffer,
@@ -125,6 +113,10 @@ module MIPPeR
 
       # Store all the variables in the model
       vars.each { |var| store_variable var }
+
+      # Update the model with variables so constraint adds succeed
+      ret = Gurobi.GRBupdatemodel @ptr
+      fail if ret != 0
     end
 
     # Add a new variable to the model
@@ -139,37 +131,18 @@ module MIPPeR
 
     # Add multiple constraints at once
     def add_constraints(constrs)
-      cbeg = []
-      cind = []
-      cval = []
-      constrs.each_with_index.map do |constr, i|
-        cbeg << cind.length
-        constr.expression.terms.each do |var, coeff|
-          cind << var.instance_variable_get(:@index)
-          cval << coeff
-        end
-      end
-
-      cbeg_buffer = FFI::MemoryPointer.new :pointer, cbeg.length
-      cbeg_buffer.write_array_of_int cbeg
-
-      cind_buffer = FFI::MemoryPointer.new :pointer, cind.length
-      cind_buffer.write_array_of_int cind
+      cbeg, cind, cval = build_constraint_matrix constrs
 
-      cval_buffer = FFI::MemoryPointer.new :pointer, cval.length
-      cval_buffer.write_array_of_double cval
-
-      sense_buffer = FFI::MemoryPointer.new :pointer, constrs.length
-      sense_buffer.write_array_of_char(constrs.map do |c|
+      cbeg_buffer = build_pointer_array cbeg, :int
+      cind_buffer = build_pointer_array cind, :int
+      cval_buffer = build_pointer_array cval, :double
+      sense_buffer = build_pointer_array(constrs.map do |c|
         gurobi_sense(c.sense)
-      end)
-
-      rhs_buffer = FFI::MemoryPointer.new :pointer, constrs.length
-      rhs_buffer.write_array_of_double constrs.map(&:rhs)
+      end, :char)
+      rhs_buffer = build_pointer_array constrs.map(&:rhs), :double
 
-      names = array_to_pointers_to_names constrs
-      names_buffer = FFI::MemoryPointer.new :pointer, constrs.length
-      names_buffer.write_array_of_pointer names
+      names_buffer = build_pointer_array array_to_pointers_to_names(constrs),
+                                         :pointer
 
       ret = Gurobi.GRBaddconstrs @ptr, constrs.length, cind.length,
                                  cbeg_buffer, cind_buffer, cval_buffer,
@@ -182,13 +155,10 @@ module MIPPeR
     # Add a new constraint to the model
     def add_constraint(constr)
       terms = constr.expression.terms
-      indexes_buffer = FFI::MemoryPointer.new :int, terms.length
-      indexes_buffer.write_array_of_int(terms.each_key.map do |var|
+      indexes_buffer = build_pointer_array(terms.each_key.map do |var|
         var.instance_variable_get(:@index)
-      end)
-
-      values_buffer = FFI::MemoryPointer.new :double, terms.length
-      values_buffer.write_array_of_double terms.values
+      end, :int)
+      values_buffer = build_pointer_array terms.values, :double
 
       ret = Gurobi.GRBaddconstr @ptr, terms.length,
                                 indexes_buffer, values_buffer,
@@ -206,6 +176,43 @@ module MIPPeR
       proc { Gurobi.GRBfreemodel ptr }
     end
 
+    # Construct a matrix of values for the given list of constraints
+    def build_constraint_matrix(constrs)
+      cbeg = []
+      cind = []
+      cval = []
+      constrs.each.map do |constr|
+        cbeg << cind.length
+        constr.expression.terms.each do |var, coeff|
+          cind << var.instance_variable_get(:@index)
+          cval << coeff
+        end
+      end
+
+      [cbeg, cind, cval]
+    end
+
+    # Save the solution to the model for access later
+    def save_solution
+      status = gurobi_status
+
+      if status == :optimized
+        objective_value = gurobi_objective
+        variable_values = Hash[@variables.map do |var|
+          dblptr = FFI::MemoryPointer.new :pointer
+          Gurobi.GRBgetdblattrarray @ptr, Gurobi::GRB_DBL_ATTR_X,
+                                    var.index, 1, dblptr
+          value = dblptr.read_array_of_double(1)[0]
+          [var.name, value]
+        end]
+      else
+        objective_value = nil
+        variable_values = {}
+      end
+
+      @solution = Solution.new status, objective_value, variable_values
+    end
+
     # Save the variable to the model and update the variable pointers
     def store_variable(var)
       # Update the variable to track the index in the model
@@ -217,8 +224,7 @@ module MIPPeR
     end
 
     def set_double_attribute(name, var_index, value)
-      buffer = FFI::MemoryPointer.new :double, 1
-      buffer.write_array_of_double [value]
+      buffer = build_pointer_array [value], :double
       ret = Gurobi.GRBsetdblattrarray @ptr, name, var_index, 1, buffer
       fail if ret != 0
     end

data/lib/mipper/lp_solve/model.rb

@@ -1,4 +1,5 @@
 module MIPPeR
+  # A linear programming model using the lp_solve solver
   class LPSolveModel < Model
     attr_reader :ptr
 
@@ -30,35 +31,8 @@ module MIPPeR
       update
 
       # Run the solver and save the status for later
-      @status = LPSolve.solve @ptr
-    end
-
-    # Get the status of the model
-    def status
-      case @status
-      when LPSolve::OPTIMAL
-        :optimized
-      when LPSolve::INFEASIBLE, LPSolve::UNBOUNDED, LPSolve::DEGENERATE
-        :invalid
-      else
-        :unknown
-      end
-    end
-
-    # The value of the objective function
-    def objective_value
-      LPSolve.get_objective @ptr
-    end
-
-    # Get the value of a variable from the model
-    def variable_value(var)
-      # To access the value of a result variable we need an index into the
-      # solution which setarts with the objective function, followed by all
-      # of the constraints, and finally the variables
-      # We explicitly ask for the number of rows since extra constraints
-      # may have been added
-      rows = LPSolve.get_Nrows(@ptr)
-      LPSolve.get_var_primalresult @ptr, rows + var.index
+      status = LPSolve.solve(@ptr)
+      save_solution status
     end
 
     def set_variable_bounds(var_index, lb, ub)
@@ -90,6 +64,52 @@ module MIPPeR
 
     private
 
+    # Build the constraint matrix and add it to the model
+    def store_constraint_matrix(constr, type)
+      # Initialize arrays used to hold the coefficients for each variable
+      row = []
+      colno = []
+      constr.expression.terms.each do |var, coeff|
+        row << coeff * 1.0
+        colno << var.instance_variable_get(:@index)
+      end
+
+      row_buffer = build_pointer_array row, :double
+      colno_buffer = build_pointer_array colno, :int
+
+      ret = LPSolve.add_constraintex(@ptr, constr.expression.terms.length,
+                                     row_buffer, colno_buffer,
+                                     type, constr.rhs)
+      fail if ret != 1
+    end
+
+    # Save the solution to the model for access later
+    def save_solution(status)
+      status = case status
+               when LPSolve::OPTIMAL
+                 :optimized
+               when LPSolve::INFEASIBLE, LPSolve::UNBOUNDED,
+                    LPSolve::DEGENERATE
+                 :invalid
+               else
+                 :unknown
+               end
+
+      if status == :optimized
+        objective_value = LPSolve.get_objective @ptr
+        rows = LPSolve.get_Nrows(@ptr)
+        variable_values = Hash[@variables.map do |var|
+          value = LPSolve.get_var_primalresult @ptr, rows + var.index
+          [var.name, value]
+        end]
+      else
+        objective_value = nil
+        variable_values = {}
+      end
+
+      @solution = Solution.new status, objective_value, variable_values
+    end
+
     # Save the constraint to the model and update the constraint pointers
     def store_constraint(constr)
       # Update the constraint to track the index in the model
@@ -114,24 +134,7 @@ module MIPPeR
         type = LPSolve::LE
       end
 
-      # Initialize arrays used to hold the coefficients for each variable
-      row = []
-      colno = []
-      constr.expression.terms.each do |var, coeff|
-        row << coeff * 1.0
-        colno << var.instance_variable_get(:@index)
-      end
-
-      row_buffer = FFI::MemoryPointer.new :pointer, row.length
-      row_buffer.write_array_of_double row
-      colno_buffer = FFI::MemoryPointer.new :pointer, colno.length
-      colno_buffer.write_array_of_int colno
-
-      ret = LPSolve.add_constraintex(@ptr, constr.expression.terms.length,
-                                     row_buffer, colno_buffer,
-                                     type, constr.rhs)
-      fail if ret != 1
-
+      store_constraint_matrix constr, type
       @constraints << constr
     end
 
@@ -147,7 +150,22 @@ module MIPPeR
       fail if ret != 1
 
       # Set variable properties
-      case var.type
+      set_variable_type index, var.type
+
+      ret = LPSolve.set_col_name(@ptr, index, var.name)
+      fail if ret != 1
+
+      ret = LPSolve.set_obj(@ptr, index, var.coefficient)
+      fail if ret != 1
+
+      set_variable_bounds index, var.lower_bound, var.upper_bound
+
+      @variables << var
+    end
+
+    # Set the type of a variable
+    def set_variable_type(index, type)
+      case type
       when :integer
         ret = LPSolve.set_int @ptr, index, 1
       when :binary
@@ -157,17 +175,8 @@ module MIPPeR
       else
         fail type
       end
-      fail if ret != 1
 
-      ret = LPSolve.set_col_name(@ptr, index, var.name)
       fail if ret != 1
-
-      ret = LPSolve.set_obj(@ptr, index, var.coefficient)
-      fail if ret != 1
-
-      set_variable_bounds index, var.lower_bound, var.upper_bound
-
-      @variables << var
     end
   end
 end

data/lib/mipper/model.rb

@@ -1,8 +1,10 @@
 module MIPPeR
+  # Stores a linear programming model for a particular solver
   class Model
     attr_reader :variables, :constraints
 
     def initialize
+      @solution = nil
       @sense = :min
 
       @variables = []
@@ -26,33 +28,22 @@ module MIPPeR
 
     # Update the model
     def update
-      if @pending_variables.length == 1
-        add_variable @pending_variables.first
-      elsif @pending_variables.length > 0
-        add_variables @pending_variables
-      end
-      @pending_variables = []
-
-      if @pending_constraints.length == 1
-        add_constraint @pending_constraints.first
-      elsif @pending_constraints.length > 0
-        add_constraints @pending_constraints
-      end
-      @pending_constraints = []
+      update_variables
+      update_constraints
     end
 
     # Write the model to a file in CPLEX LP format
-    def write_lp(filename)
+    def write_lp(_filename)
       fail NotImplementedError
     end
 
     # Write the model to a file in MPS format
-    def write_mps(filename)
+    def write_mps(_filename)
       fail NotImplementedError
     end
 
     # Set the sense of the model
-    def sense=(sense)
+    def sense=(_sense)
       fail NotImplementedError
     end
 
@@ -63,35 +54,72 @@ module MIPPeR
 
     # Get the status of the model
     def status
-      :unknown
+      if @solution.nil?
+        :unknown
+      else
+        @solution.status
+      end
     end
 
     # Compute an irreducible inconsistent subsytem for the model
-    def compute_IIS
+    def compute_iis
       fail NotImplementedError
     end
 
-    # The value of the objective function
+    # Get the value of the objective function from a previous solution
     def objective_value
-      fail NotImplementedError
+      @solution.objective_value unless @solution.nil?
+    end
+
+    # Get the value of a variable from a previous solution
+    def variable_value(var)
+      @solution.variable_values[var.name] unless @solution.nil?
     end
 
     protected
 
+    # Shortcut to build a C array from a Ruby array
+    def build_pointer_array(array, type)
+      buffer = FFI::MemoryPointer.new type, array.length
+      buffer.send("write_array_of_#{type}".to_sym,  array)
+
+      buffer
+    end
+
+    # Just add the variable as an array
     def add_variable(var)
       add_variables([var])
     end
 
+    # Just add the constraint as an array
     def add_constraint(constr)
       add_constraints([constr])
     end
 
-    def set_variable_bounds(var_index, ub, lb)
+    def set_variable_bounds(_var_index, _ub, _lb)
       fail NotImplementedError
     end
 
-    def variable_value(var)
-      fail NotImplementedError
+    private
+
+    # Add any pending variables to the model
+    def update_variables
+      if @pending_variables.length == 1
+        add_variable @pending_variables.first
+      elsif @pending_variables.length > 0
+        add_variables @pending_variables
+      end
+      @pending_variables = []
+    end
+
+    # Add any pending constraints to the model
+    def update_constraints
+      if @pending_constraints.length == 1
+        add_constraint @pending_constraints.first
+      elsif @pending_constraints.length > 0
+        add_constraints @pending_constraints
+      end
+      @pending_constraints = []
     end
   end
 end

data/lib/mipper/solution.rb

@@ -0,0 +1,11 @@
+module MIPPeR
+  class Solution
+    attr_accessor :status, :objective_value, :variable_values
+
+    def initialize(status, objective_value, variable_values)
+      @status = status
+      @objective_value = objective_value
+      @variable_values = variable_values
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mipper
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Michael Mior
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-15 00:00:00.000000000 Z
+date: 2016-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -51,6 +51,7 @@ files:
 - lib/mipper/lp_solve/ext/constants.rb
 - lib/mipper/lp_solve/model.rb
 - lib/mipper/model.rb
+- lib/mipper/solution.rb
 - lib/mipper/util.rb
 - lib/mipper/variable.rb
 homepage: https://github.com/michaelmior/mipper