mipper 0.0.4

data/lib/mipper/lp_solve/ext.rb

@@ -0,0 +1,35 @@
+require 'ffi'
+
+module MIPPeR
+  module LPSolve
+    # Hide the constants inside the MIPPeR::LPSolve module
+    module_eval File.read(File.expand_path './ext/constants.rb',
+                          File.dirname(__FILE__))
+
+    extend FFI::Library
+    ffi_lib 'lpsolve55'
+
+    attach_function :get_objective, [:pointer], :double
+    attach_function :get_ptr_primal_solution, [:pointer, :pointer], :int
+    attach_function :add_constraintex, [:pointer, :int, :pointer, :pointer,
+                                        :int, :double], :int
+    attach_function :make_lp, [:int, :int], :pointer
+    attach_function :resize_lp, [:pointer, :int, :int], :int
+    attach_function :set_binary, [:pointer, :int, :int], :int
+    attach_function :set_int, [:pointer, :int, :int], :int
+    attach_function :set_bounds, [:pointer, :int, :double, :double], :int
+    attach_function :set_col_name, [:pointer, :int, :string], :int
+    attach_function :set_add_rowmode, [:pointer, :int], :int
+    attach_function :set_row_name, [:pointer, :int, :string], :int
+    attach_function :set_upbo, [:pointer, :int, :double], :int
+    attach_function :set_lowbo, [:pointer, :int, :double], :int
+    attach_function :set_obj, [:pointer, :int, :double], :int
+    attach_function :solve, [:pointer], :int
+    attach_function :set_sense, [:pointer, :int], :void
+    attach_function :add_columnex, [:pointer, :int, :pointer, :pointer], :int
+    attach_function :delete_lp, [:pointer], :int
+    attach_function :get_var_primalresult, [:pointer, :int], :double
+    attach_function :set_outputfile, [:pointer, :string], :int
+    attach_function :get_Nrows, [:pointer], :int
+  end
+end

data/lib/mipper/lp_solve/model.rb

@@ -0,0 +1,173 @@
+module MIPPeR
+  class LPSolveModel < Model
+    attr_reader :ptr
+
+    def initialize
+      super
+
+      @var_count = 0
+      @constr_count = 0
+
+      # Construct a new model
+      @ptr = FFI::AutoPointer.new LPSolve.make_lp(0, 0),
+                                  LPSolve.method(:delete_lp)
+
+      # Disable output
+      ret = LPSolve.set_outputfile @ptr, ''
+      fail if ret != 1
+    end
+
+    # Set the sense of the model
+    def sense=(sense)
+      @sense = sense
+      sense = sense == :min ? 0 : 1
+      LPSolve.set_sense @ptr, sense
+    end
+
+    # Optimize the model
+    def optimize
+      # Ensure pending variables and constraints are added
+      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
+    end
+
+    def set_variable_bounds(var_index, lb, ub)
+      ret = LPSolve.set_bounds @ptr, var_index, lb, ub
+      fail if ret != 1
+    end
+
+    protected
+
+    # Add multiple variables to the model simultaneously
+    def add_variables(vars)
+      # Allocate space for the new variables
+      ret = LPSolve.resize_lp(@ptr, @constraints.length,
+                              @variables.length + vars.length)
+      fail if ret != 1
+
+      # Store all the variables in the model
+      vars.each { |var| store_variable var }
+    end
+
+    # Add multiple constraints at once
+    def add_constraints(constrs)
+      ret = LPSolve.resize_lp(@ptr, @constraints.length + constrs.length,
+                              @variables.length)
+      fail if ret != 1
+
+      constrs.each { |constr| store_constraint constr }
+    end
+
+    private
+
+    # 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
+      index = LPSolve.get_Nrows(@ptr)
+      constr.instance_variable_set :@model, self
+      constr.instance_variable_set :@index, index
+      @constr_count += 1
+
+      # Set constraint properties
+      if constr.name
+        ret = LPSolve.set_row_name(@ptr, index, constr.name)
+        fail if ret != 1
+      end
+
+      # Determine the correct constant for the type of constraint
+      case constr.sense
+      when :==
+        type = LPSolve::EQ
+      when :>=
+        type = LPSolve::GE
+      when :<=
+        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
+
+      @constraints << constr
+    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
+      index = @var_count + 1
+      var.instance_variable_set :@model, self
+      var.instance_variable_set :@index, index
+      @var_count += 1
+
+      ret = LPSolve.add_columnex @ptr, 0, nil, nil
+      fail if ret != 1
+
+      # Set variable properties
+      case var.type
+      when :integer
+        ret = LPSolve.set_int @ptr, index, 1
+      when :binary
+        ret = LPSolve.set_binary @ptr, index, 1
+      when :continuous
+        ret = LPSolve.set_int @ptr, index, 0
+      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/lp_solve.rb

@@ -0,0 +1,4 @@
+require_relative 'lp_solve/ext'
+
+require_relative 'lp_solve/model'
+

data/lib/mipper/model.rb

@@ -0,0 +1,92 @@
+module MIPPeR
+  class Model
+    attr_reader :variables, :constraints
+
+    def initialize
+      @sense = :min
+
+      @variables = []
+      @constraints = []
+
+      @pending_variables = []
+      @pending_constraints = []
+    end
+
+    # Add new objects (variables and constraints) to the model
+    def <<(obj)
+      case obj
+      when Variable
+        @pending_variables << obj
+      when Constraint
+        @pending_constraints << obj
+      else
+        fail TypeError
+      end
+    end
+
+    # 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 = []
+    end
+
+    # Write the model to a file
+    def write(filename)
+      fail NotImplementedError
+    end
+
+    # Set the sense of the model
+    def sense=(sense)
+      fail NotImplementedError
+    end
+
+    # Optimize the model
+    def optimize
+      fail NotImplementedError
+    end
+
+    # Get the status of the model
+    def status
+      :unknown
+    end
+
+    # Compute an irreducible inconsistent subsytem for the model
+    def compute_IIS
+      fail NotImplementedError
+    end
+
+    # The value of the objective function
+    def objective_value
+      fail NotImplementedError
+    end
+
+    protected
+
+    def add_variable(var)
+      add_variables([var])
+    end
+
+    def add_constraint(constr)
+      add_constraints([constr])
+    end
+
+    def set_variable_bounds(var_index, ub, lb)
+      fail NotImplementedError
+    end
+
+    def variable_value(var)
+      fail NotImplementedError
+    end
+  end
+end

data/lib/mipper/util.rb

@@ -0,0 +1,5 @@
+class Integer
+  def finite?
+    true
+  end
+end

data/lib/mipper/variable.rb

@@ -0,0 +1,79 @@
+module MIPPeR
+  class Variable
+    attr_accessor :constraints
+    attr_reader :lower_bound, :upper_bound, :coefficient, :type, :name, :model,
+                :index
+
+    def initialize(lb, ub, coeff, type, name = nil)
+      @lower_bound = lb
+      @upper_bound = ub
+      @coefficient = coeff
+      @type = type
+      @name = name
+      @constraints = []
+
+      # These will be populated when this is added to a model
+      @model = nil
+      @index = nil
+    end
+
+    # Set the variable lower bound
+    def lower_bound=(lb)
+      @model.set_variable_bounds @index, lb, @upper_bound unless @model.nil?
+      @lower_bound = lb
+    end
+
+    # Set the variable upper bound
+    def upper_bound=(ub)
+      @model.set_variable_bounds @index, @lower_bound, ub unless @model.nil?
+      @upper_bound = ub
+    end
+
+    # Get the final value of this variable
+    def value
+      # Model must be solved to have a value
+      return nil unless @model && @model.status == :optimized
+
+      value = @model.variable_value self
+
+      case @type
+      when :integer
+        value.round
+      when :binary
+        [false, true][value.round]
+      else
+        value
+      end
+    end
+
+    # Create a {LinExpr} consisting of a single term
+    # which is this variable multiplied by a constant
+    def *(coeff)
+      fail TypeError unless coeff.is_a? Numeric
+
+      LinExpr.new({ self => coeff })
+    end
+
+    def +(other)
+      case other
+      when LinExpr
+        other + self * 1.0
+      when Variable
+        LinExpr.new({self => 1.0, other => 1.0})
+      else
+        fail TypeError
+      end
+    end
+
+    # Produce the name of the variable and the value if the model is solved
+    def inspect
+      if @model && @model.status == :optimized
+        value = self.value
+      else
+        value = '?'
+      end
+
+      "#{@name} = #{value}"
+    end
+  end
+end

data/lib/mipper.rb

@@ -0,0 +1,11 @@
+require_relative 'mipper/util'
+
+require_relative 'mipper/constraint'
+require_relative 'mipper/expression'
+require_relative 'mipper/model'
+require_relative 'mipper/variable'
+
+require_relative 'mipper/cbc'
+require_relative 'mipper/lp_solve'
+require_relative 'mipper/glpk'
+require_relative 'mipper/gurobi'

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: mipper
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Michael Mior
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+description: MIPPeR is a Ruby interface to various mixed integer programming solvers
+email: michael.mior@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mipper.rb
+- lib/mipper/cbc.rb
+- lib/mipper/cbc/ext.rb
+- lib/mipper/cbc/model.rb
+- lib/mipper/constraint.rb
+- lib/mipper/expression.rb
+- lib/mipper/glpk.rb
+- lib/mipper/glpk/ext.rb
+- lib/mipper/glpk/ext/constants.rb
+- lib/mipper/glpk/ext/structs.rb
+- lib/mipper/glpk/model.rb
+- lib/mipper/gurobi.rb
+- lib/mipper/gurobi/env.rb
+- lib/mipper/gurobi/ext.rb
+- lib/mipper/gurobi/ext/constants.rb
+- lib/mipper/gurobi/model.rb
+- lib/mipper/lp_solve.rb
+- lib/mipper/lp_solve/ext.rb
+- lib/mipper/lp_solve/ext/constants.rb
+- lib/mipper/lp_solve/model.rb
+- lib/mipper/model.rb
+- lib/mipper/util.rb
+- lib/mipper/variable.rb
+homepage: https://github.com/michaelmior/mipper
+licenses:
+- GPLv3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: A Ruby interface to various MIP solvers
+test_files: []
+has_rdoc: