guruby 0.0.1

data/lib/guruby/ext/gurobi.rb

@@ -0,0 +1,37 @@
+require 'ffi'
+
+module Gurobi
+  extend FFI::Library
+  ffi_lib File.join(ENV['GUROBI_HOME'], 'lib/libgurobi56.so')
+
+  attach_function :GRBloadenv, [:pointer, :string], :int
+  attach_function :GRBsetintparam, [:pointer, :string, :int], :int
+  attach_function :GRBgeterrormsg, [:pointer], :string
+  attach_function :GRBfreeenv, [:pointer], :void
+
+  attach_function :GRBnewmodel, [:pointer, :pointer, :string, :int,
+                                 :pointer, :pointer, :pointer, :pointer,
+                                 :pointer], :int
+  attach_function :GRBupdatemodel, [:pointer], :int
+  attach_function :GRBfreemodel, [:pointer], :int
+
+  attach_function :GRBaddvar, [:pointer, :int, :pointer, :pointer,
+                               :double, :double, :double, :char, :string], :int
+  attach_function :GRBaddvars, [:pointer, :int, :int, :pointer, :pointer,
+                                :pointer, :pointer, :pointer, :pointer,
+                                :pointer, :pointer], :int
+  attach_function :GRBaddconstr, [:pointer, :int, :pointer, :pointer, :char,
+                                  :double, :string], :int
+  attach_function :GRBoptimize, [:pointer], :int
+  attach_function :GRBcomputeIIS, [:pointer], :int
+  attach_function :GRBwrite, [:pointer, :string], :int
+
+  attach_function :GRBsetintattr, [:pointer, :string, :int], :int
+
+  attach_function :GRBgetintattr, [:pointer, :string, :pointer], :int
+  attach_function :GRBgetdblattr, [:pointer, :string, :pointer], :int
+  attach_function :GRBgetdblattrarray, [:pointer, :string, :int, :int,
+                                        :pointer], :int
+  attach_function :GRBsetdblattrarray, [:pointer, :string, :int, :int,
+                                        :pointer], :int
+end

data/lib/guruby/model.rb

@@ -0,0 +1,121 @@
+require_relative 'ext'
+
+module Guruby
+  class Model
+    attr_reader :ptr, :environment, :variables, :constraints
+
+    def initialize(env)
+      @environment = env
+
+      @ptr = FFI::MemoryPointer.new :pointer
+      Gurobi.GRBnewmodel env.ptr, @ptr, 'model', 0, nil, nil, nil, nil, nil
+      @ptr = @ptr.read_pointer
+
+      # Ensure the model is freed
+      ObjectSpace.define_finalizer self, self.class.finalize(@ptr)
+
+      @var_count = 0
+      @variables = []
+      @constraints = []
+    end
+
+    # Add new objects (variables and constraints) to the model
+    def <<(obj)
+      case obj
+      when Variable
+        add_variable obj
+      when Constraint
+        add_constraint obj
+      else
+        fail TypeError
+      end
+    end
+
+    # Update the model
+    def update
+      ret = Gurobi.GRBupdatemodel @ptr
+      fail if ret != 0
+    end
+
+    # Write the model to a file
+    def write(filename)
+      Gurobi.GRBwrite @ptr, filename
+    end
+
+    # Set the sense of the model
+    def set_sense(sense)
+      ret = Gurobi.GRBsetintattr @ptr, GRB_INT_ATTR_MODELSENSE, sense
+      fail if ret != 0
+    end
+
+    # Optimize the model
+    def optimize
+      ret = Gurobi.GRBoptimize @ptr
+      fail if ret != 0
+    end
+
+    # Get the status of the model
+    def status
+      intptr = FFI::MemoryPointer.new :pointer
+      ret = Gurobi.GRBgetintattr @ptr, GRB_INT_ATTR_STATUS, intptr
+      fail if ret != 0
+      intptr.read_int
+    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
+      dblptr = FFI::MemoryPointer.new :pointer
+      ret = Gurobi.GRBgetdblattr @ptr, GRB_DBL_ATTR_OBJVAL, dblptr
+      fail if ret != 0
+      dblptr.read_double
+    end
+
+    private
+
+    # Free the model
+    def self.finalize(ptr)
+      proc { Gurobi.GRBfreemodel ptr }
+    end
+
+    # Add a new variable to the model
+    def add_variable(var)
+      ret = Gurobi.GRBaddvar @ptr, 0, nil, nil, var.coefficient,
+                             var.lower_bound, var.upper_bound,
+                             var.type.ord, var.name
+      fail if ret != 0
+
+      # Update the variable to track the index in the model
+      var.instance_variable_set :@model, self
+      var.instance_variable_set :@index, @var_count
+      @var_count += 1
+
+      @variables << var
+    end
+
+    # 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|
+        var.instance_variable_get(:@index)
+      end)
+
+      values_buffer = FFI::MemoryPointer.new :double, terms.length
+      values_buffer.write_array_of_double terms.values
+
+      ret = Gurobi.GRBaddconstr @ptr, terms.length,
+                                indexes_buffer, values_buffer,
+                                constr.sense.ord, constr.rhs, constr.name
+      fail if ret != 0
+
+      @constraints << constr
+    end
+
+  end
+end

data/lib/guruby/var.rb

@@ -0,0 +1,88 @@
+module Guruby
+  class Variable
+    attr_reader :lower_bound, :upper_bound, :coefficient, :type, :name, :model
+
+    def initialize(lb, ub, coeff, type, name = nil)
+      @lower_bound = lb
+      @upper_bound = ub
+      @coefficient = coeff
+      @type = type
+      @name = name
+
+      # 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)
+      set_double_attribute GRB_DBL_ATTR_LB, lb
+      @lower_bound = lb
+    end
+
+    # Set the variable upper bound
+    def upper_bound=(ub)
+      set_double_attribute GRB_DBL_ATTR_UB, ub
+      @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 == GRB_OPTIMAL
+
+      dblptr = FFI::MemoryPointer.new :pointer
+      Gurobi::GRBgetdblattrarray @model.instance_variable_get(:@ptr),
+                                 GRB_DBL_ATTR_X, @index, 1, dblptr
+      value = dblptr.read_array_of_double(1)[0]
+
+      case @type
+      when GRB_INTEGER
+        value.round
+      when GRB_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
+      when Variable
+        self * 1 + other * 1
+      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 == GRB_OPTIMAL
+        value = self.value
+      else
+        value = '?'
+      end
+
+      "#{@name} = #{value}"
+    end
+
+    private
+
+    def set_double_attribute(name, value)
+      buffer = FFI::MemoryPointer.new :double, 1
+      buffer.write_array_of_double [value]
+      ret = Gurobi.GRBsetdblattrarray model.ptr, name, @index, 1, buffer
+      fail if ret != 0
+    end
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: guruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Michael Mior
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-27 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: Guruby is a Ruby interface to the Gurobi solver
+email: michael.mior@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/guruby.rb
+- lib/guruby/constr.rb
+- lib/guruby/env.rb
+- lib/guruby/expr.rb
+- lib/guruby/ext.rb
+- lib/guruby/ext/constants.rb
+- lib/guruby/ext/gurobi.rb
+- lib/guruby/model.rb
+- lib/guruby/var.rb
+homepage: https://github.com/michaelmior/guruby
+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 the Gurobi solver
+test_files: []
+has_rdoc: