ruby-cbc 0.3.8 → 0.3.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3d05d2dddacdfb1243b0ccbe0db95ef785002175
-  data.tar.gz: b9ea06e2a20a3b60a8a28c7a7ccfac5f7af73e3f
+  metadata.gz: b400b079a0878a8b069de6806d0a39307ec7cbaa
+  data.tar.gz: c12f4fb20c21d4f0a2f56ee300f14ab7af90a693
 SHA512:
-  metadata.gz: 4d876f561b81578e8d1b69108e5c4e024eb2c52b66b34eeaade45b4f941d357145a2889e3ad71919bd0a979d7ee3f7a28d92223c263e67777a9a2cce842a8561
-  data.tar.gz: eb4aed1071260b46aacd4ec4c228a56a1dfb24e8e691c3d4e7ad941348e3521200d747413a75de80fca2bbef3e2a0456f81c66bc23637a9b84dcbe8ca82811e8
+  metadata.gz: 7d60c2ca3659d4de0f4c2fc5619b372755b6d403fef0daa62f04117b4fab5a9c3808e9b1f1369e59445ffae46bc08ee31f393984e3714a887c31f2cea5758174
+  data.tar.gz: d57f7aad33405975ca485b8a3cdb7ab5da8646ef49a1966b8dc0a6bb6ec5ab66a26236f3293ac0b30e3be23136bde96c2ea66fc0d4623d40e264660368334f9c

data/Rakefile

@@ -10,29 +10,17 @@ ensure
   Dir.chdir(original_dir)
 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'
-#   ext.tmp_dir = "tmp"
-#   ext.name = 'cbc_wrapper'
-# end
+RSpec::Core::RakeTask.new(:spec)
 
-SHARED_LIBRARY_EXTENSION = RUBY_PLATFORM.include?("darwin") ? 'bundle' : 'so'
-EXTENSION = 'lib/ruby-cbc/cbc_wrapper.'+SHARED_LIBRARY_EXTENSION
-
-desc "Use extconf.rb and make to build the extension."
-task :build_extension => EXTENSION
-
-file EXTENSION => 'ext/ruby-cbc/cbc_wrap.c' do
-  puts "start"
-  in_dir('ext/ruby-cbc') do
-    system("ruby extconf.rb")
-    system("make")
-  end
+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'
 end
 
-CLEAN.include('ext/ruby-cbc/Makefile', 'ext/ruby-cbc/conftest.dSYM', 'ext/ruby-cbc/mkmf.log', 'ext/ruby-cbc/cbc_wrap.o')
+task :default => [:spec]
 
-task :default => [:build_extension, :spec]
+task :benchmark do
+  ruby "test/benchmark.rb"
+end

data/lib/ruby-cbc.rb

@@ -15,6 +15,7 @@ ilp/objective
 ilp/term
 ilp/term_array
 ilp/var
+utils/compressed_row_storage
 )
 
 files.each do |file|

data/lib/ruby-cbc/conflict_solver.rb

@@ -2,66 +2,102 @@ module Cbc
 
   class ConflictSolver
 
-    def initialize(model)
-     @model = model
+    def initialize(problem)
+      # clone the model minus the objective
+      @model = Model.new
+      @model.vars = problem.model.vars
+      @model.constraints = problem.model.constraints
+      @problem = problem
     end
 
-    # Assuming there is a conflict
     def find_conflict
-      continuous = is_continuous_conflict?
-      conflict_set = []
-      all_constraints = @model.constraints
-      nb_constraints = all_constraints.count
+      crs = Util::CompressedRowStorage.from_model(@model)
+      continuous = is_continuous_conflict?(crs)
+      unless continuous
+        p = Problem.from_compressed_row_storage(crs, continuous: false)
+        return [] unless infeasible?(p)
+      end
+      clusters = [crs.nb_constraints]
+      max_iter = 1
+      conflict_set_size = 0
       loop do
-        m = Model.new
-        m.vars = @model.vars
-        m.constraints = conflict_set
-        return conflict_set if infeasible?(m, continuous: continuous)
+        range_idxs = first_failing(conflict_set_size, crs, continuous: continuous, max_iterations: max_iter)
+        break if range_idxs.nil?
+        puts "RANGE #{range_idxs}"
+        crs = crs.restrict_to_n_constraints(range_idxs.max + 1)
+        crs.move_constraint_to_start(range_idxs)
+        clusters.insert(0, range_idxs.size)
+        clusters[-1] = range_idxs.min - conflict_set_size
+        conflict_set_size += range_idxs.size
+
+        # Test conflict set
+        crs2 = crs.restrict_to_n_constraints(conflict_set_size)
+        problem = Problem.from_compressed_row_storage(crs2, continuous: continuous)
+        if infeasible?(problem)
+          puts "CONFLICT"
+          clusters.delete_at(-1)
+          break if clusters.size == conflict_set_size
+
+          crs = crs2
+        end
 
-        constraint_idx = first_failing(conflict_set, all_constraints, nb_constraints, continuous: continuous)
-        return conflict_set if !constraint_idx
+        nb_clusters_one_constraint = 0
+        clusters.reverse_each do |nb_constraints|
+          break if nb_constraints > 1
+          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))
+          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)
+        end
 
-        nb_constraints = constraint_idx
-        conflict_set << all_constraints[constraint_idx]
+        conflict_set_size = crs.nb_constraints - clusters[-1]
+        puts "CLUSTERS #{clusters.inspect}"
+        puts "VARS #{crs.col_idx.uniq.size}"
       end
+      crs.model.constraints[0, conflict_set_size]
     end
 
-    def is_continuous_conflict?
-      # Same model without objective
-      model = Model.new
-      model.vars = @model.vars
-      model.constraints = @model.constraints
-      infeasible?(model, continuous: true)
+    def is_continuous_conflict?(crs)
+      problem = Problem.from_compressed_row_storage(crs, continuous: true)
+      infeasible?(problem)
     end
 
   private
     # finds the first constraint from constraints that makes the problem infeasible
-    def first_failing(conflict_set, constraints, nb_constraints, continuous: false)
-      min_nb_constraints = 0
-      max_nb_constraints = nb_constraints + 1
+    def first_failing(conflict_set_size, crs, continuous: false, max_iterations: nil)
+      min_idx = conflict_set_size
+      max_idx = crs.nb_constraints - 1
 
       loop do
-        m = Model.new
-        m.vars = @model.vars
-
-        half_constraints = (max_nb_constraints + min_nb_constraints) / 2
-        m.constraints = conflict_set + constraints.take(half_constraints)
-        if infeasible?(m, continuous: continuous)
-          max_nb_constraints = half_constraints
+        unless max_iterations.nil?
+          return min_idx..max_idx if max_iterations <= 0
+          max_iterations -= 1
+        end
+        half_constraint_idx = (max_idx + min_idx) / 2
+        puts "Refining: [#{min_idx}:#{max_idx}] -> #{half_constraint_idx}"
+        crs2 = crs.restrict_to_n_constraints(half_constraint_idx + 1)
+        problem = Problem.from_compressed_row_storage(crs2, continuous: continuous)
+        if infeasible?(problem)
+          max_idx = half_constraint_idx
+          puts "                                INFEAS"
         else
-          min_nb_constraints = half_constraints
+          min_idx = half_constraint_idx + 1
+          puts "                                FEAS"
         end
-        if max_nb_constraints - min_nb_constraints <= 1
-          return nil if max_nb_constraints > constraints.count
-          return max_nb_constraints - 1
+        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
       end
       # Shouldn't come here if the whole problem is infeasible
       return nil
     end
 
-    def infeasible?(model, continuous: false)
-      problem = Problem.new(model, continuous: continuous)
+    def infeasible?(problem)
       problem.solve
       problem.proven_infeasible?
     end

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

@@ -19,7 +19,7 @@ module Ilp
     end
 
     def to_function_s
-      "#{function_name || 'constraint'}(#{vars.join(', ')})"
+      "#{function_name || 'constraint'}(#{vars.map(&:name).join(', ')})"
     end
 
     def to_s

data/lib/ruby-cbc/model.rb

@@ -1,5 +1,3 @@
-require "set"
-
 module Cbc
 
   INF = 1.0 / 0.0 # Useful for ranges
@@ -24,7 +22,7 @@ module Cbc
     attr_accessor :vars, :constraints, :objective, :name
 
     def initialize(name: "ILP Problem")
-      @vars = Set.new
+      @vars = []
       @constraints = []
       @objective = nil
       @name = name
@@ -82,7 +80,7 @@ module Cbc
     end
 
     def to_problem
-      Cbc::Problem.new(self)
+      Cbc::Problem.from_model(self)
     end
 
     def to_s

data/lib/ruby-cbc/problem.rb

@@ -1,55 +1,80 @@
 module Cbc
   class Problem
 
-    attr_reader :model
+    attr_accessor :model, :variable_index, :crs
 
-    def initialize(model, continuous: false)
-
-      @int_arrays = []
-      @double_arrays = []
+    def self.from_model(model, continuous: false)
+      crs = Util::CompressedRowStorage.from_model(model)
+      from_compressed_row_storage(crs, continuous: continuous)
+    end
 
-      @model = model
-      @variables = {}
-      vars = model.vars
-      vars_data = {}
-      vars.each_with_index do |v, idx|
-        @variables[v] = idx
-        vars_data[v] = VarData.new(v, idx, [], [])
+    def self.from_compressed_row_storage(crs, continuous: false)
+      new.tap do |p|
+        p.model = crs.model
+        p.variable_index = crs.variable_index
+        p.crs = crs
+        p.create_cbc_problem(continuous: continuous)
       end
+    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
+    CCS = Struct.new(:col_ptr, :row_idx, :values) do
+      def nb_vars
+        col_ptr.size - 1
       end
+    end
 
-      indexes = []
-      rows = []
-      coefs = []
+    def self.crs_to_ccs(crs)
+      nb_per_column = Array.new(crs.col_idx.max.to_i + 1, 0)
+      nb_values = crs.values.size
 
-      vars.each_with_index do |v, idx|
-        v_data = vars_data[v]
-        indexes[idx] = rows.count
-        rows.concat v_data.constraints
-        coefs.concat v_data.coefs
+      crs.col_idx.each { |col_idx| nb_per_column[col_idx] += 1 }
+
+      ccs = CCS.new(Array.new(nb_per_column.size + 1), Array.new(nb_values), Array.new(nb_values))
+      ccs.col_ptr[0] = 0
+      idx = 0
+      while idx < nb_per_column.size
+        ccs.col_ptr[idx + 1] = ccs.col_ptr[idx] + nb_per_column[idx]
+        idx += 1
       end
 
-      indexes << rows.count
+      cols_idx = ccs.col_ptr.clone
+      row_idx = 0
+      end_row_idx = crs.row_ptr.size - 1
+      while row_idx < end_row_idx do
+        current_idx = crs.row_ptr[row_idx]
+        last_idx = crs.row_ptr[row_idx + 1] - 1
+        while current_idx <= last_idx do
+          col_idx = crs.col_idx[current_idx]
+          ccs_col_idx = cols_idx[col_idx]
+          cols_idx[col_idx] += 1
+          ccs.row_idx[ccs_col_idx] = row_idx
+          ccs.values[ccs_col_idx] = crs.values[current_idx]
+          current_idx += 1
+        end
+        row_idx += 1
+      end
+      ccs
+    end
 
-      objective = Array.new(vars.count, 0)
+    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
         model.objective.terms.each do |term|
-          objective[vars_data[term.var].col_idx] = term.mult
+          objective[@variable_index[term.var]] = 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)
+      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)
+
 
       # Segmentation errors when setting name
       # Cbc_wrapper.Cbc_setProblemName(@cbc_model, model.name) if model.name
@@ -59,18 +84,15 @@ module Cbc
         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
+      idx = 0
+      while idx < @crs.nb_constraints do
+        c = model.constraints[idx]
+        set_constraint_bounds(c, idx)
+        idx += 1
       end
-      model.vars.each_with_index do |v, idx|
+      idx = 0
+      while idx < ccs.nb_vars do
+        v = model.vars[idx]
         if continuous
           Cbc_wrapper.Cbc_setContinuous(@cbc_model, idx)
         else
@@ -83,14 +105,28 @@ module Cbc
         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?
+        idx += 1
       end
 
       ObjectSpace.define_finalizer(self, self.class.finalizer(@cbc_model, @int_arrays, @double_arrays))
 
       @default_solve_params = {
-          log: 0,
-        }
+        log: 0,
+      }
+
+
+    end
 
+    def set_constraint_bounds(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
 
     def solve(params = {})
@@ -99,10 +135,12 @@ 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)
-      idx = @variables[var]
+      idx = @variable_index[var]
       return nil if idx.nil?
       if var.kind == Ilp::Var::CONTINUOUS_KIND
         @solution[idx]
@@ -141,7 +179,7 @@ module Cbc
     end
 
     def find_conflict
-      @conflict_set ||= ConflictSolver.new(model).find_conflict
+      @conflict_set ||= ConflictSolver.new(self).find_conflict
     end
 
     def find_conflict_vars
@@ -163,21 +201,25 @@ module Cbc
   private
 
     def to_int_array(array)
-      c_array = Cbc_wrapper::IntArray.new(array.count)
-      array.each_with_index { |value, idx| c_array[idx] = value }
+      c_array = Cbc_wrapper::IntArray.new(array.size)
+      idx = 0
+      while idx < array.size do
+        c_array[idx] = array[idx]
+        idx += 1
+      end
       @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 }
+      c_array = Cbc_wrapper::DoubleArray.new(array.size)
+      idx = 0
+      while idx < array.size do
+        c_array[idx] = array[idx]
+        idx += 1
+      end
       @double_arrays << c_array
       c_array
     end
-
-    VarData = Struct.new(:variable, :col_idx, :constraints, :coefs)
   end
-
-
 end

data/lib/ruby-cbc/utils/compressed_row_storage.rb

@@ -0,0 +1,82 @@
+module Util
+  class CompressedRowStorage
+
+    attr_accessor :model, :variable_index, :row_ptr, :col_idx, :values
+
+    def self.from_model(model)
+      new.tap do |crs|
+        crs.model = model
+        crs.variable_index = {}
+        idx = 0
+        while idx < model.vars.size do
+          v = model.vars[idx]
+          crs.variable_index[v] = idx
+          idx += 1
+        end
+        crs.fill_matrix
+      end
+    end
+
+    def nb_constraints
+      row_ptr.count - 1
+    end
+
+    def fill_matrix
+      nb_values = model.constraints.map { |c| c.terms.count }.inject(:+) || 0
+      @row_ptr = Array.new(model.constraints.count)
+      @col_idx = Array.new(nb_values)
+      @values = Array.new(nb_values)
+
+      nb_cols = 0
+      c_idx = 0
+      while c_idx < @model.constraints.size do
+        constraint = @model.constraints[c_idx]
+        @row_ptr[c_idx] = nb_cols
+        nb_insert = constraint.terms.count
+        @col_idx[nb_cols, nb_insert] = constraint.terms.map { |term| variable_index[term.var] }
+        @values[nb_cols, nb_insert] = constraint.terms.map { |term| term.mult }
+        nb_cols += nb_insert
+        c_idx += 1
+      end
+      @row_ptr << @col_idx.count
+    end
+
+    def restrict_to_n_constraints(nb_constraints)
+      length_of_values = @row_ptr[nb_constraints]
+      CompressedRowStorage.new.tap do |crs|
+        crs.model = @model
+        crs.variable_index = @variable_index
+        crs.row_ptr = @row_ptr[0, nb_constraints + 1]
+        crs.col_idx = @col_idx[0, length_of_values]
+        crs.values = @values[0, length_of_values]
+      end
+    end
+
+    def move_constraint_to_start(range_idxs)
+      # Move in the model
+      constraints = model.constraints[range_idxs]
+      @model.constraints = @model.constraints.clone
+      @model.constraints[constraints.count, range_idxs.max] = model.constraints[0, range_idxs.min]
+      @model.constraints[0, constraints.count] = constraints
+
+      # Move in the matrix
+      constraint_start_idx = @row_ptr[range_idxs.min]
+      nb_vars = @row_ptr[range_idxs.max + 1] - constraint_start_idx
+      offset= @row_ptr[range_idxs.min]
+      new_begin = @row_ptr[range_idxs].map! { |idx| idx - offset }
+      ((range_idxs.count)..(range_idxs.max)).reverse_each do |idx|
+        @row_ptr[idx] = @row_ptr[idx - range_idxs.count] + nb_vars
+      end
+      @row_ptr[0, range_idxs.count] = new_begin
+      move_block_to_start(@col_idx, constraint_start_idx, nb_vars)
+      move_block_to_start(@values, constraint_start_idx, nb_vars)
+    end
+
+    def move_block_to_start(array, block_start_idx, nb_values)
+      to_move = array[block_start_idx, nb_values]
+      array[nb_values, block_start_idx] = array[0, block_start_idx]
+      array[0, nb_values] = to_move
+    end
+
+  end
+end

data/lib/ruby-cbc/version.rb

@@ -1,3 +1,3 @@
 module Cbc
-  VERSION = "0.3.8"
+  VERSION = "0.3.9"
 end

data/ruby-cbc.gemspec

@@ -25,6 +25,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake-compiler"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "benchmark-ips"
+  spec.add_development_dependency "ruby-prof"
 
   spec.add_dependency "cbc-wrapper", '~> 2.9.7.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-cbc
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.3.9
 platform: ruby
 authors:
 - Guillaume Verger
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-04-12 00:00:00.000000000 Z
+date: 2016-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,6 +94,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-prof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: cbc-wrapper
   requirement: !ruby/object:Gem::Requirement
@@ -134,6 +162,7 @@ files:
 - lib/ruby-cbc/ilp/var.rb
 - lib/ruby-cbc/model.rb
 - lib/ruby-cbc/problem.rb
+- lib/ruby-cbc/utils/compressed_row_storage.rb
 - lib/ruby-cbc/version.rb
 - ruby-cbc.gemspec
 homepage: https://github.com/gverger/ruby-cbc
@@ -161,4 +190,3 @@ signing_key:
 specification_version: 4
 summary: Wrapper around Cbc Linear Programming Solver
 test_files: []
-has_rdoc: