ruby-cbc 0.1.9

data/lib/ruby-cbc/ilp/var.rb

@@ -0,0 +1,62 @@
+module Ilp
+  class Var
+    attr_accessor :kind, :name, :lower_bound, :upper_bound
+
+    BINARY_KIND = :binary
+    INTEGER_KIND = :integer
+    CONTINUOUS_KIND = :continuous
+
+    def initialize(name: nil, kind: INTEGER_KIND, lower_bound: nil, upper_bound: nil)
+      @kind = kind
+      @name = name
+      @name = ('a'..'z').to_a.shuffle[0,8].join if name.nil?
+      @lower_bound = lower_bound
+      @upper_bound = upper_bound
+    end
+
+    def bounds=(range)
+      @lower_bound = range.min
+      @upper_bound = range.max
+    end
+
+    def bounds
+      @lower_bound..@upper_bound
+    end
+
+    def +(vars)
+      Ilp::Term.new(self) + vars
+    end
+
+    def -(vars)
+      Ilp::Term.new(self) - vars
+    end
+
+    def -@
+      Ilp::Term.new(self, -1)
+    end
+
+    def *(mult)
+      Ilp::Term.new(self) * mult
+    end
+
+    def ==(vars)
+      Ilp::Term.new(self) == vars
+    end
+
+    def <=(vars)
+      Ilp::Term.new(self) <= vars
+    end
+
+    def >=(vars)
+      Ilp::Term.new(self) >= vars
+    end
+
+    def coerce(num)
+      [Ilp::Term.new(self), num]
+    end
+
+    def to_s
+      name
+    end
+  end
+end

data/lib/ruby-cbc/model.rb

@@ -0,0 +1,125 @@
+require "set"
+
+module Cbc
+
+  INF = 1.0 / 0.0 # Useful for ranges
+
+  class Model
+
+
+    attr_accessor :vars, :constraints, :objective, :name
+
+    def initialize(name: "ILP Problem")
+      @vars = Set.new
+      @constraints = Set.new
+      @objective = nil
+      @name = name
+    end
+
+    def int_var(range = nil, name: nil)
+      var(Ilp::Var::INTEGER_KIND, range, name)
+    end
+
+    def int_var_array(length, range = nil, names: nil)
+      array_var(length, Ilp::Var::INTEGER_KIND, range, names)
+    end
+
+    def bin_var(name: nil)
+      var(Ilp::Var::BINARY_KIND, nil, name)
+    end
+
+    def bin_var_array(length, names: nil)
+      array_var(length, Ilp::Var::BINARY_KIND, range, names)
+    end
+
+    def cont_var(range = nil, name: nil)
+      var(Ilp::Var::CONTINUOUS_KIND, range, name)
+    end
+
+    def cont_var_array(length, range = nil, name: nil)
+      array_var(length, Ilp::Var::CONTINUOUS_KIND, range, names)
+    end
+
+    def enforce(constraint)
+      constraints << constraint
+    end
+
+    def minimize(expression)
+      @objective = Ilp::Objective.new(expression, Ilp::Objective::MINIMIZE) if expression
+      self
+    end
+
+    def maximize(expression)
+      @objective = Ilp::Objective.new(expression, Ilp::Objective::MAXIMIZE) if expression
+      self
+    end
+
+    def to_problem
+      Cbc::Problem.new(self)
+    end
+
+    def to_s
+      str = ""
+      if objective
+      str << objective.to_s << "\n"
+      else
+        str << "Maximize\n  0 #{vars.first.to_s}\n"
+      end
+      str << "\nSubject To\n"
+      constraints.each do |cons|
+        str << "  " << cons.to_s << "\n"
+      end
+      bounded_vars = vars.select{ |v| v.kind != Ilp::Var::BINARY_KIND }
+      if bounded_vars.any?
+        str << "\nBounds\n"
+        bounded_vars.each { |v| str << "  #{lb_to_s(v.lower_bound)} <= #{v} <= #{ub_to_s(v.upper_bound)}\n" }
+      end
+
+      int_vars = vars.select{ |v| v.kind == Ilp::Var::INTEGER_KIND }
+      if int_vars.any?
+        str << "\nGenerals\n"
+        int_vars.each { |v| str << "  #{v}\n" }
+      end
+
+      bin_vars = vars.select{ |v| v.kind == Ilp::Var::BINARY_KIND }
+      if bin_vars.any?
+        str << "\nBinaries\n"
+        bin_vars.each { |v| str << "  #{v}\n" }
+      end
+      str << "\nEnd\n"
+
+      str
+    end
+
+  private
+    def array_var(length, kind, range, names)
+      ar = Array.new(length) { var(kind, range, nil) }
+      ar.zip(names).map{ |var, name| var.name = name } unless names.nil?
+      ar
+    end
+
+    def var(kind, range, name)
+      if range.nil?
+        v = Ilp::Var.new(kind: kind, name: name)
+        @vars << v
+        return v
+      end
+      v = Ilp::Var.new(kind: kind, name: name, lower_bound: range.min, upper_bound: range.max)
+      @vars << v
+      v
+    end
+
+    def lb_to_s(lb) 
+      return "-inf" if ! lb || lb == -Cbc::INF
+      return "+inf" if lb == Cbc::INF
+      return "#{lb}"
+    end
+
+    def ub_to_s(ub) 
+      return "+inf" if ! ub || ub == Cbc::INF
+      return "-inf" if ub == -Cbc::INF
+      return "#{ub}"
+    end
+
+  end
+end

data/lib/ruby-cbc/problem.rb

@@ -0,0 +1,170 @@
+# require "../../ext/ruby-cbc/install/lib/cbc_wrapper"
+
+module Cbc
+  class Problem
+
+
+    def initialize(model)
+
+      @int_arrays = []
+      @double_arrays = []
+
+      @variables = {}
+      vars = model.vars
+      vars_data = {}
+      vars.each_with_index do |v, idx|
+        @variables[v] = idx
+        vars_data[v] = VarData.new(v, idx, [], [])
+      end
+
+      model.constraints.each_with_index do |c, idx|
+        c.terms.each do |term|
+          v_data = vars_data[term.var]
+          v_data.constraints << idx
+          v_data.coefs << term.mult
+        end
+      end
+
+      indexes = []
+      rows = [] 
+      coefs = []
+
+      vars.each_with_index do |v, idx|
+        v_data = vars_data[v]
+        indexes[idx] = rows.count
+        rows += v_data.constraints
+        coefs += v_data.coefs
+      end
+
+      indexes << rows.count
+
+      objective = Array.new(vars.count, 0)
+      if model.objective
+        model.objective.terms.each do |term|
+          objective[vars_data[term.var].col_idx] = term.mult
+        end
+      end
+
+      @cbc_model = Cbc_wrapper.Cbc_newModel
+      Cbc_wrapper.Cbc_loadProblem(@cbc_model, model.vars.count, model.constraints.count,
+                                 to_int_array(indexes), to_int_array(rows),
+                                 to_double_array(coefs), nil, nil, to_double_array(objective),
+                                 nil, nil)
+
+      # Segmentation errors when setting name
+      # Cbc_wrapper.Cbc_setProblemName(@cbc_model, model.name) if model.name
+
+      if model.objective
+        obj_sense = model.objective.objective_function == Ilp::Objective::MINIMIZE ? 1 : -1
+        Cbc_wrapper.Cbc_setObjSense(@cbc_model, obj_sense)
+      end
+
+      model.constraints.each_with_index do |c, idx|
+        case c.type
+        when Ilp::Constraint::LESS_OR_EQ
+          Cbc_wrapper.Cbc_setRowUpper(@cbc_model, idx, c.bound)
+        when Ilp::Constraint::GREATER_OR_EQ
+          Cbc_wrapper.Cbc_setRowLower(@cbc_model, idx, c.bound)
+        when Ilp::Constraint::EQUALS
+          Cbc_wrapper.Cbc_setRowUpper(@cbc_model, idx, c.bound)
+          Cbc_wrapper.Cbc_setRowLower(@cbc_model, idx, c.bound)
+        end
+      end
+      model.vars.each_with_index do |v, idx|
+        case v.kind 
+        when Ilp::Var::INTEGER_KIND
+          Cbc_wrapper.Cbc_setInteger(@cbc_model, idx)
+        when Ilp::Var::BINARY_KIND
+          Cbc_wrapper.Cbc_setInteger(@cbc_model, idx)
+          v.bounds = 0..1
+        when Ilp::Var::CONTINUOUS_KIND
+          Cbc_wrapper.Cbc_setContinuous(@cbc_model, idx)
+        end
+        Cbc_wrapper.Cbc_setColLower(@cbc_model, idx, v.lower_bound) unless v.lower_bound.nil?
+        Cbc_wrapper.Cbc_setColUpper(@cbc_model, idx, v.upper_bound) unless v.upper_bound.nil?
+      end
+
+      ObjectSpace.define_finalizer(self, self.class.finalizer(@cbc_model, @int_arrays, @double_arrays))
+
+      @default_solve_params = {
+          log: 0,
+        }
+
+    end
+
+    def solve(params = {})
+      @default_solve_params.merge(params).each do |name, value|
+        Cbc_wrapper.Cbc_setParameter(@cbc_model, name.to_s, value.to_s)
+      end
+      Cbc_wrapper.Cbc_solve(@cbc_model)
+      @solution = Cbc_wrapper::DoubleArray.frompointer(Cbc_wrapper.Cbc_getColSolution(@cbc_model))
+    end
+
+    def value_of(var)
+      idx = @variables[var]
+      return nil if idx.nil?
+      @solution[idx]
+    end
+
+    def set_time_limit(seconds)
+      @default_solve_params[:sec] = seconds
+    end
+
+    def proven_optimal?
+      Cbc_wrapper.Cbc_isProvenOptimal(@cbc_model) == 1
+    end
+
+    def proven_infeasible?
+      Cbc_wrapper.Cbc_isProvenInfeasible(@cbc_model) == 1
+    end
+
+    def time_limit_reached?
+      Cbc_wrapper.Cbc_isSecondsLimitReached(@cbc_model)
+    end
+
+    def solution_limit_reached?
+      Cbc_wrapper.Cbc_isSolutionLimitReached(@cbc_model)
+    end
+
+    def objective_value
+      Cbc_wrapper.Cbc_getObjValue(@cbc_model)
+    end
+
+    # Returns the best know bound so far
+    def best_bound
+      Cbc_wrapper.Cbc_getBestPossibleObjValue(@cbc_model)
+    end
+
+    def self.finalizer(cbc_model, int_arrays, double_arrays)
+      proc do
+        Cbc_wrapper.Cbc_deleteModel(cbc_model)
+        int_arrays.each { |ar| Cbc_wrapper.delete_intArray(ar) }
+        double_arrays.each { |ar| Cbc_wrapper.delete_doubleArray(ar) }
+      end
+    end
+
+    def write
+      Cbc_wrapper.Cbc_writeMps(@cbc_model, "test")
+    end
+
+  private
+
+    def to_int_array(array)
+      c_array = Cbc_wrapper::IntArray.new(array.count)
+      array.each_with_index { |value, idx| c_array[idx] = value }
+      @int_arrays << c_array
+      c_array
+    end
+
+    def to_double_array(array)
+      c_array = Cbc_wrapper::DoubleArray.new(array.count)
+      array.each_with_index { |value, idx| c_array[idx] = value }
+      @double_arrays << c_array
+      c_array 
+    end
+
+    VarData = Struct.new(:variable, :col_idx, :constraints, :coefs)
+  end
+
+  
+end

data/lib/ruby-cbc/version.rb

@@ -0,0 +1,3 @@
+module Cbc
+  VERSION = "0.1.9"
+end

data/lib/ruby-cbc.rb

@@ -0,0 +1,21 @@
+require "ruby-cbc/version"
+
+module Cbc
+end
+
+files = %w(
+model
+problem
+version
+ilp/constant
+ilp/constraint
+ilp/objective
+ilp/term
+ilp/term_array
+ilp/var
+)
+
+require File.expand_path("../../ext/ruby-cbc/cbc_wrapper", __FILE__)
+files.each do |file|
+  require File.expand_path("../ruby-cbc/#{file}", __FILE__)
+end

data/ruby-cbc.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby-cbc/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruby-cbc"
+  spec.version       = Cbc::VERSION
+  spec.authors       = ["Guillaume Verger"]
+  spec.email         = ["verger.guillaume@gmail.com"]
+
+  spec.summary       = "Wrapper around Cbc Linear Programming Solver"
+  spec.description   = "Wrapper around Cbc Linear Programming Solver"
+  spec.homepage      = "https://github.com/gverger/ruby-cbc"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    # spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib", "ext"]
+  spec.extensions    << "ext/ruby-cbc/extconf.rb"
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-byebug"
+end