ruby-cbc 0.3.16 → 0.3.19

data/.travis.yml

@@ -1,4 +1,6 @@
 language: ruby
 rvm:
   - 2.2.3
-before_install: gem install bundler -v 1.10.6
+before_install:
+  - sudo apt-get -y install coinor-libcbc-dev
+  - gem install bundler -v 1.10.6

data/Gemfile

@@ -1,4 +1,4 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in cbc.gemspec
 gemspec

data/README.md

@@ -1,4 +1,5 @@
 [![Build Status](https://travis-ci.org/gverger/ruby-cbc.svg?branch=master)](https://travis-ci.org/gverger/ruby-cbc)
+
 # Ruby-Cbc
 
 This gem is using Cbc, an Integer Linear Programming Library, to provide optimization problems solving
@@ -8,6 +9,13 @@ It uses the version 2.9.9 of Cbc, and requires the version 2.9.9 of gem cbc-wrap
 
 ## Installation
 
+You need to have `cbc` installed for `ruby-cbc` to work.
+
+- On a mac, you can execute `brew install cbc`
+- On Debian and Ubuntu, use `apt-get install coinor-libcbc-dev`
+- On Archlinux, use `pacman -S coin-or-cbc`
+- On docker you can check the dockerfiles in test/installation-tests/
+
 Add this line to your application's Gemfile:
 
 ```ruby
@@ -22,16 +30,25 @@ Or install it yourself as:
 
     $ gem install ruby-cbc
 
-The gem includes a version of the Coin-Or Cbc library. If the system on which
-it is installed is not Linux 64bits, it downloads the library sources and
-recompiles them at installation.
+### Heroku
+
+On Heroku, you will need to tweak your installation a bit: you can install the cbc library with
+the [Apt](https://github.com/heroku/heroku-buildpack-apt) buildpack with an Aptfile of:
+
+```
+coinor-libcbc-dev
+```
+
+You will need to set LD_LIBRARY_PATH so it can find LAPACK and BLAS (see this [issue](https://github.com/heroku/heroku-buildpack-apt/issues/35)).
 
-It also works on Heroku.
+```
+heroku config:set LD_LIBRARY_PATH=/app/.apt/usr/lib/x86_64-linux-gnu/lapack:/app/.apt/usr/lib/x86_64-linux-gnu/blas
+```
 
 ## Usage
 
 ```ruby
-# The same Brief Example as found in section 1.3 of 
+# The same Brief Example as found in section 1.3 of
 # glpk-4.44/doc/glpk.pdf.
 #
 # maximize
@@ -52,39 +69,45 @@ m.maximize(10 * x1 + 6 * x2 + 4 * x3)
 
 m.enforce(x1 + x2 + x3 <= 100)
 m.enforce(10 * x1 + 4 * x2 + 5 * x3 <= 600)
-m.enforce(2 * x1 + 2 * x2 + 6* x3 <= 300)
+m.enforce(2 * x1 + 2 * x2 + 6 * x3 <= 300)
 
 p = m.to_problem
 
 p.solve
 
-if ! p.proven_infeasible?
+unless p.proven_infeasible?
   puts "x1 = #{p.value_of(x1)}"
   puts "x2 = #{p.value_of(x2)}"
   puts "x3 = #{p.value_of(x3)}"
 end
 ```
+
 ### Modelling
 
 Let's have a model :
+
 ```ruby
 model = Cbc::Model.new
 ```
+
 #### The variables
 
 3 variable kinds are available:
+
 ```ruby
 x = model.bin_var(name: "x")        # a binary variable (i.e. can take values 0 and 1)
 y = model.int_var(L..U, name: "y")  # a integer variable, L <= y <= U
 z = model.cont_var(L..U, name: "z") # a continuous variable, L <= z <= U
 ```
+
 Name is optional and used only when displaying the model.
 
 If you don't specify the range, the variables are free.
-You can also use ```Cbc::INF``` as the infinity bound.
+You can also use `Cbc::INF` as the infinity bound.
 
 Each one of these 3 kinds have also an array method that generate several variables.
 For instance to generate 3 positive integer variables named x, y and z :
+
 ```ruby
 x, y, z = model.int_var_array(3, 0..Cbc::INF, names: ["x", "y", "z"])
 ```
@@ -92,12 +115,15 @@ x, y, z = model.int_var_array(3, 0..Cbc::INF, names: ["x", "y", "z"])
 #### The constraints
 
 You can enforce constraints:
+
 ```ruby
 model.enforce(x + y - z <= 10)
 ```
+
 You are not restricted to usual linear programming rules when writing a constraint.
-Usually you would have to write ```x - y = 0``` to express ```x = y```.
+Usually you would have to write `x - y = 0` to express `x = y`.
 Ruby-Cbc allows you to put variables and constants on both sides of the comparison operator. You can write
+
 ```ruby
 model.enforce(x - y == 0)
 model.enforce(x == y)
@@ -107,12 +133,14 @@ model.enforce(0 == x - y)
 
 Ruby-Cbc allows you to name your constraints. Beware that their name is not an unique id. It is only a helper
 for human readability, and several constraints can share the same function name.
+
 ```ruby
 model.enforce(my_function_name: x + y <= 50)
 model.constraints.map(&:to_function_s) # => ["my_function_name(x, y)"]
 ```
 
 Linear constraints are usually of the form
+
 ```ruby
 a1 * x1 + a2 * x2 + ... + an * xn <= C
 a1 * x1 + a2 * x2 + ... + an * xn >= C
@@ -120,14 +148,17 @@ a1 * x1 + a2 * x2 + ... + an * xn == C
 ```
 
 With Ruby-Cbc you can write
+
 ```ruby
 2 * (2 + 5 * x) + 4 * 5 + 1 == 1 + 4 * 5 * y
 ```
+
 The (in)equation must still be a **linear** (in)equation, you cannot multiply two variables !
 
 #### Objective
 
 You can set the objective:
+
 ```ruby
 model.maximize(3 * x + 2 * y)
 model.minimize(3 * x + 2 * y)
@@ -136,12 +167,15 @@ model.minimize(3 * x + 2 * y)
 #### Displaying the model
 
 the `Model` instances have a `to_s` method. You can then run
+
 ```ruby
 puts model
 ```
+
 The model will be printed in LP format.
 
 For instance:
+
 ```
 Maximize
   + 10 x1 + 6 x2 + 4 x3
@@ -167,25 +201,30 @@ End
 ### Solving
 
 To solve the model, you need to first transform it to a problem.
+
 ```ruby
 problem = model.to_problem
 ```
 
 You can define a time limit to the resolution
+
 ```ruby
 problem.set_time_limit(nb_seconds)
 ```
 
 You can solve the Linear Problem
+
 ```ruby
 problem.solve
 ```
 
 You can specify arguments that match the cbc command line
+
 ```ruby
 problem.solve(sec: 60) # equivalent to $ cbc -sec 60
 problem.solve(log: 1)  # equivalent to $ cbc -log 1
 ```
+
 For more examples of available options, if `coinor-cbc` is installed run
 
     $ cbc
@@ -193,6 +232,7 @@ For more examples of available options, if `coinor-cbc` is installed run
 then type `?`
 
 Once `problem.solve` has finished you can query the status:
+
 ```ruby
 problem.proven_infeasible?  # will tell you if the problem has no solution
 problem.proven_optimal?     # will tell you if the problem is solved optimally
@@ -200,6 +240,7 @@ problem.time_limit_reached? # Will tell you if the solve timed out
 ```
 
 To have the different values, do
+
 ```ruby
 problem.objective_value # Will tell you the value of the best objective
 problem.best_bound      # Will tell you the best known bound
@@ -211,16 +252,19 @@ problem.value_of(var)   # will tell you the computed value or a variable
 
 Sometimes a problem has no feasible solution. In this case, one may wonder what is the minimum subset of conflicting
 inequations. For this prupose, you can use
+
 ```ruby
 problem.find_conflict      # Will return an array of constraints that form an unsatifiable set
 problem.find_conflict_vars # Will return all variables involved in the unsatisfiable minimum set of constraints
 ```
+
 It finds a minimum subset of constraints that make the problem unsatisfiable. Note that there could be several of them,
 but the solver only computes the first one it finds. Note also that it does so by solving several instances
 of relaxed versions of the problem. It might take some time! It is based on QuickXplain
 (http://dl.acm.org/citation.cfm?id=1597177).
 
 One way to see the results nicely could be
+
 ```ruby
 problem.find_conflict.map(&:to_function_s)
 ```
@@ -228,4 +272,3 @@ problem.find_conflict.map(&:to_function_s)
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/gverger/ruby-cbc.
-

data/Rakefile

@@ -1,6 +1,6 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
-require 'rake/extensiontask'
+require "rake/extensiontask"
 
 def in_dir(path)
   original_dir = Dir.pwd
@@ -12,14 +12,14 @@ end
 
 RSpec::Core::RakeTask.new(:spec)
 
-spec = Gem::Specification.load('ruby-cbc.gemspec')
-Rake::ExtensionTask.new('ruby-cbc', spec) do |ext|
-  ext.lib_dir = 'lib/ruby-cbc'
+spec = Gem::Specification.load("ruby-cbc.gemspec")
+Rake::ExtensionTask.new("ruby-cbc", spec) do |ext|
+  ext.lib_dir = "lib/ruby-cbc"
   ext.tmp_dir = "tmp"
-  ext.name = 'cbc_wrapper'
+  ext.name = "cbc_wrapper"
 end
 
-task :default => [:spec]
+task default: [:spec]
 
 task :benchmark do
   ruby "test/benchmark.rb"

data/lib/ruby-cbc/conflict_solver.rb

@@ -19,7 +19,8 @@ module Cbc
       max_iter = 1
       conflict_set_size = 0
       loop do
-        range_idxs = first_failing(conflict_set_size, crs, continuous: continuous, max_iterations: max_iter)
+        range_idxs =
+          first_failing(conflict_set_size, crs, continuous: continuous, max_iterations: max_iter)
         break if range_idxs.nil?
         crs = crs.restrict_to_n_constraints(range_idxs.max + 1)
         crs.move_constraint_to_start(range_idxs)
@@ -43,7 +44,9 @@ module Cbc
           nb_clusters_one_constraint += 1
         end
         if nb_clusters_one_constraint > 0
-          crs.move_constraint_to_start((crs.nb_constraints - nb_clusters_one_constraint)..(crs.nb_constraints - 1))
+          crs.move_constraint_to_start(
+            (crs.nb_constraints - nb_clusters_one_constraint)..(crs.nb_constraints - 1)
+          )
           clusters[nb_clusters_one_constraint, clusters.size - nb_clusters_one_constraint] =
             clusters[0, clusters.size - nb_clusters_one_constraint]
           clusters[0, nb_clusters_one_constraint] = Array.new(nb_clusters_one_constraint, 1)
@@ -83,14 +86,12 @@ module Cbc
           min_idx = half_constraint_idx + 1
           # puts "                                FEAS"
         end
-        if max_idx == min_idx
-          # puts "found: max = #{max_idx} min = #{min_idx} nb = #{crs.nb_constraints}"
-          return nil if max_idx > crs.nb_constraints
-          return min_idx..max_idx
-        end
+        next if max_idx != min_idx
+        return nil if max_idx > crs.nb_constraints
+        return min_idx..max_idx
       end
       # Shouldn't come here if the whole problem is infeasible
-      return nil
+      nil
     end
 
     def infeasible?(problem)

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

@@ -0,0 +1,49 @@
+module Ilp
+  class Constant
+    attr_accessor :value
+    def initialize(value)
+      raise ArgumentError, "Argument is not numeric" unless value.is_a? Numeric
+      @value = value
+    end
+
+    def <=(other)
+      other >= value
+    end
+
+    def <(other)
+      other > value
+    end
+
+    def >=(other)
+      other <= value
+    end
+
+    def >(other)
+      other < value
+    end
+
+    def ==(other)
+      other == value
+    end
+
+    def *(other)
+      other * value
+    end
+
+    def +(other)
+      other + value
+    end
+
+    def -(other)
+      -1 * other + value
+    end
+
+    def to_s
+      value.to_s
+    end
+
+    def pretty_print
+      value.to_s
+    end
+  end
+end

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

@@ -4,8 +4,7 @@ module Ilp
     GREATER_OR_EQ = :greater_or_eq
     EQUALS = :equals
 
-    attr_reader :terms, :type, :bound
-    attr_accessor :function_name
+    attr_accessor :terms, :type, :bound, :function_name
 
     def initialize(terms, type, bound)
       @terms = terms - bound
@@ -26,7 +25,7 @@ module Ilp
       LESS_OR_EQ => "<=",
       GREATER_OR_EQ => ">=",
       EQUALS => "="
-    }
+    }.freeze
 
     def to_s
       sign = SIGN_TO_STRING[@type] || "??"

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

@@ -3,7 +3,7 @@ module Ilp
     MINIMIZE = :min
     MAXIMIZE = :max
 
-    attr_reader :terms, :objective_function
+    attr_accessor :terms, :objective_function
     def initialize(terms, objective_function = MAXIMIZE)
       @terms = terms
       @terms = Ilp::Term.new(@terms) if @terms.is_a? Ilp::Var

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

@@ -1,7 +1,6 @@
 module Ilp
   class Term
-    attr_reader :var
-    attr_accessor :mult
+    attr_accessor :mult, :var
 
     def initialize(var, mult = 1)
       @mult = mult
@@ -28,20 +27,13 @@ module Ilp
       Ilp::TermArray.new([self]) >= other
     end
 
-    def combine_in(other_term)
-      return Term.new(var, mult) unless other_term
-      raise "Terms cannot be combined: #{self} and #{other_term}" unless var.equal? other_term.var
-      other_term.mult += mult
-      other_term
-    end
-
     def *(other)
       raise ArgumentError, "Argument is not numeric" unless other.is_a? Numeric
       Ilp::Term.new(@var, @mult * other)
     end
 
     def coerce(num)
-      [Ilp::TermArray.new([self]), num]
+      [Ilp::Constant.new(num), Ilp::TermArray.new([self])]
     end
 
     def to_s

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

@@ -1,8 +1,10 @@
+require "forwardable"
+
 module Ilp
   class TermArray
     extend Forwardable
 
-    attr_reader :terms
+    attr_accessor :terms
     def_delegators :@terms, :map, :each, :size
 
     def initialize(terms)
@@ -31,7 +33,7 @@ module Ilp
     end
 
     def *(other)
-      raise ArgumentError, 'Argument is not numeric' unless other.is_a? Numeric
+      raise ArgumentError, "Argument is not numeric" unless other.is_a? Numeric
       new_terms = terms.map { |term| term * other }
       TermArray.new(new_terms)
     end
@@ -45,8 +47,9 @@ module Ilp
         when Numeric
           constant += term
         when Ilp::Term
-          variable = term.var
-          hterms[variable] = term.combine_in(hterms[variable])
+          v = term.var
+          hterms[v] ||= Ilp::Term.new(v, 0)
+          hterms[v].mult += term.mult
         end
       end
       reduced = hterms.map { |_, term| term unless term.mult.zero? }
@@ -68,7 +71,7 @@ module Ilp
     end
 
     def coerce(value)
-      [value, self]
+      [Ilp::Constant.new(value), self]
     end
 
     def to_s

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

@@ -52,7 +52,7 @@ module Ilp
     end
 
     def coerce(num)
-      [Ilp::Term.new(self), num]
+      [Ilp::Constant.new(num), self]
     end
 
     def to_s

data/lib/ruby-cbc/model.rb

@@ -91,7 +91,7 @@ module Cbc
       constraints.each do |cons|
         str << "  #{cons}\n"
       end
-      bounded_vars = vars.select { |v| v.kind != Ilp::Var::BINARY_KIND }
+      bounded_vars = vars.reject { |v| v.kind == Ilp::Var::BINARY_KIND }
       unless bounded_vars.empty?
         str << "\nBounds\n"
         bounded_vars.each do |v|
@@ -133,16 +133,16 @@ module Cbc
       v
     end
 
-    def lb_to_s(lb)
-      return "-inf" if lb.nil? || lb == -Cbc::INF
-      return "+inf" if lb == Cbc::INF
-      lb.to_s
+    def lb_to_s(lower_bound)
+      return "-inf" if lower_bound.nil? || lower_bound == -Cbc::INF
+      return "+inf" if lower_bound == Cbc::INF
+      lower_bound.to_s
     end
 
-    def ub_to_s(ub)
-      return "+inf" if ub.nil? || ub == Cbc::INF
-      return "-inf" if ub == -Cbc::INF
-      ub.to_s
+    def ub_to_s(upper_bound)
+      return "+inf" if upper_bound.nil? || upper_bound == Cbc::INF
+      return "-inf" if upper_bound == -Cbc::INF
+      upper_bound.to_s
     end
   end
 end

data/lib/ruby-cbc/problem.rb

@@ -56,9 +56,6 @@ module Cbc
     end
 
     def create_cbc_problem(continuous: false)
-      @int_arrays = []
-      @double_arrays = []
-
       ccs = self.class.crs_to_ccs(@crs)
       objective = Array.new(ccs.nb_vars, 0)
       if model.objective
@@ -69,10 +66,18 @@ module Cbc
 
       @cbc_model = Cbc_wrapper.Cbc_newModel
       Cbc_wrapper.Cbc_loadProblem(
-        @cbc_model, ccs.nb_vars, @crs.nb_constraints,
-        to_int_array(ccs.col_ptr), to_int_array(ccs.row_idx),
-        to_double_array(ccs.values), nil, nil, to_double_array(objective),
-        nil, nil)
+        @cbc_model,
+        ccs.nb_vars,
+        @crs.nb_constraints,
+        to_int_array(ccs.col_ptr),
+        to_int_array(ccs.row_idx),
+        to_double_array(ccs.values),
+        nil,
+        nil,
+        to_double_array(objective),
+        nil,
+        nil
+      )
 
       # Segmentation errors when setting name
       # Cbc_wrapper.Cbc_setProblemName(@cbc_model, model.name) if model.name
@@ -106,22 +111,20 @@ module Cbc
         idx += 1
       end
 
-      ObjectSpace.define_finalizer(self, self.class.finalizer(@cbc_model, @int_arrays, @double_arrays))
+      ObjectSpace.define_finalizer(self, self.class.finalizer(@cbc_model))
 
-      @default_solve_params = {
-        log: 0
-      }
+      @default_solve_params = { log: 0 }
     end
 
-    def set_constraint_bounds(c, idx)
-      case c.type
+    def set_constraint_bounds(constraint, idx)
+      case constraint.type
       when Ilp::Constraint::LESS_OR_EQ
-        Cbc_wrapper.Cbc_setRowUpper(@cbc_model, idx, c.bound)
+        Cbc_wrapper.Cbc_setRowUpper(@cbc_model, idx, constraint.bound)
       when Ilp::Constraint::GREATER_OR_EQ
-        Cbc_wrapper.Cbc_setRowLower(@cbc_model, idx, c.bound)
+        Cbc_wrapper.Cbc_setRowLower(@cbc_model, idx, constraint.bound)
       when Ilp::Constraint::EQUALS
-        Cbc_wrapper.Cbc_setRowUpper(@cbc_model, idx, c.bound)
-        Cbc_wrapper.Cbc_setRowLower(@cbc_model, idx, c.bound)
+        Cbc_wrapper.Cbc_setRowUpper(@cbc_model, idx, constraint.bound)
+        Cbc_wrapper.Cbc_setRowLower(@cbc_model, idx, constraint.bound)
       end
     end
 
@@ -131,8 +134,6 @@ module Cbc
       end
       Cbc_wrapper.Cbc_solve(@cbc_model)
       @solution = Cbc_wrapper::DoubleArray.frompointer(Cbc_wrapper.Cbc_getColSolution(@cbc_model))
-      @double_arrays << @solution
-      @solution
     end
 
     def value_of(var)
@@ -145,9 +146,12 @@ module Cbc
       end
     end
 
+    # Keep this one for back compatibility
+    # rubocop:disable Naming/AccessorMethodName
     def set_time_limit(seconds)
       @default_solve_params[:sec] = seconds
     end
+    # rubocop:enable Naming/AccessorMethodName
 
     def proven_optimal?
       Cbc_wrapper.Cbc_isProvenOptimal(@cbc_model) == 1
@@ -175,18 +179,16 @@ module Cbc
     end
 
     def find_conflict
-      @conflict_set ||= ConflictSolver.new(self).find_conflict
+      @find_conflict ||= ConflictSolver.new(self).find_conflict
     end
 
     def find_conflict_vars
-      @conflict_vars ||= find_conflict.map(&:vars).flatten.uniq
+      @find_conflict_vars ||= find_conflict.map(&:vars).flatten.uniq
     end
 
-    def self.finalizer(cbc_model, int_arrays, double_arrays)
+    def self.finalizer(cbc_model)
       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
 
@@ -203,7 +205,6 @@ module Cbc
         c_array[idx] = array[idx]
         idx += 1
       end
-      @int_arrays << c_array
       c_array
     end
 
@@ -214,7 +215,6 @@ module Cbc
         c_array[idx] = array[idx]
         idx += 1
       end
-      @double_arrays << c_array
       c_array
     end
   end

data/lib/ruby-cbc/version.rb

@@ -1,3 +1,3 @@
 module Cbc
-  VERSION = "0.3.16"
+  VERSION = "0.3.19".freeze
 end

data/lib/ruby-cbc.rb

@@ -4,18 +4,19 @@ require "cbc-wrapper"
 module Cbc
 end
 
-files = %w(
+files = %w[
   conflict_solver
   model
   problem
   version
+  ilp/constant
   ilp/constraint
   ilp/objective
   ilp/term
   ilp/term_array
   ilp/var
   utils/compressed_row_storage
-)
+]
 
 files.each do |file|
   require File.expand_path("../ruby-cbc/#{file}", __FILE__)