ruby-cbc 0.3.10 → 0.3.12

data/lib/ruby-cbc/model.rb

@@ -1,5 +1,4 @@
 module Cbc
-
   INF = 1.0 / 0.0 # Useful for ranges
 
   def self.add_all(variables)
@@ -10,15 +9,13 @@ module Cbc
       when Ilp::Var
         Ilp::Term.new(variable)
       else
-        raise 'Not a variable, a term or a numeric'
+        raise "Not a variable, a term or a numeric"
       end
     end
     Ilp::TermArray.new(to_add)
   end
 
   class Model
-
-
     attr_accessor :vars, :constraints, :objective, :name
 
     def initialize(name: "ILP Problem")
@@ -48,7 +45,7 @@ module Cbc
       var(Ilp::Var::CONTINUOUS_KIND, range, name)
     end
 
-    def cont_var_array(length, range = nil, name: nil)
+    def cont_var_array(length, range = nil, names: nil)
       array_var(length, Ilp::Var::CONTINUOUS_KIND, range, names)
     end
 
@@ -57,12 +54,12 @@ module Cbc
         if constraint.instance_of? Ilp::Constraint
           self.constraints << constraint
         elsif constraint.instance_of? Array
-          self.constraints += constraint
+          self.constraints.concat constraint
         elsif constraint.instance_of? Hash
-          constraint.each do |name, c|
-            self.constraints << c
-            c.function_name = name.to_s
+          to_add = constraint.map do |name, cons|
+            cons.tap { |c| c.function_name = name.to_s }
           end
+          self.constraints.concat to_add
         else
           puts "Not a constraint: #{constraint}"
         end
@@ -84,30 +81,32 @@ module Cbc
     end
 
     def to_s
-      str = ""
-      if objective
-      str << objective.to_s << "\n"
-      else
-        str << "Maximize\n  0 #{vars.first.to_s}\n"
-      end
+      str = if objective
+              "#{objective}\n"
+            else
+              "Maximize\n  0 #{vars.first}\n"
+            end
+
       str << "\nSubject To\n"
       constraints.each do |cons|
-        str << "  " << cons.to_s << "\n"
+        str << "  #{cons}\n"
       end
-      bounded_vars = vars.select{ |v| v.kind != Ilp::Var::BINARY_KIND }
-      if bounded_vars.any?
+      bounded_vars = vars.select { |v| v.kind != Ilp::Var::BINARY_KIND }
+      unless bounded_vars.empty?
         str << "\nBounds\n"
-        bounded_vars.each { |v| str << "  #{lb_to_s(v.lower_bound)} <= #{v} <= #{ub_to_s(v.upper_bound)}\n" }
+        bounded_vars.each do |v|
+          str << "  #{lb_to_s(v.lower_bound)} <= #{v} <= #{ub_to_s(v.upper_bound)}\n"
+        end
       end
 
-      int_vars = vars.select{ |v| v.kind == Ilp::Var::INTEGER_KIND }
-      if int_vars.any?
+      int_vars = vars.select { |v| v.kind == Ilp::Var::INTEGER_KIND }
+      unless int_vars.empty?
         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?
+      bin_vars = vars.select { |v| v.kind == Ilp::Var::BINARY_KIND }
+      unless bin_vars.empty?
         str << "\nBinaries\n"
         bin_vars.each { |v| str << "  #{v}\n" }
       end
@@ -116,35 +115,34 @@ module Cbc
       str
     end
 
-  private
+    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.zip(names).each { |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)
+      v = if range.nil?
+            Ilp::Var.new(kind: kind, name: name)
+          else
+            Ilp::Var.new(kind: kind, name: name, lower_bound: range.min, upper_bound: range.max)
+          end
       @vars << v
       v
     end
 
     def lb_to_s(lb)
-      return "-inf" if ! lb || lb == -Cbc::INF
+      return "-inf" if lb.nil? || lb == -Cbc::INF
       return "+inf" if lb == Cbc::INF
-      return "#{lb}"
+      lb.to_s
     end
 
     def ub_to_s(ub)
-      return "+inf" if ! ub || ub == Cbc::INF
+      return "+inf" if ub.nil? || ub == Cbc::INF
       return "-inf" if ub == -Cbc::INF
-      return "#{ub}"
+      ub.to_s
     end
-
   end
 end

data/lib/ruby-cbc/problem.rb

@@ -1,6 +1,5 @@
 module Cbc
   class Problem
-
     attr_accessor :model, :variable_index, :crs
 
     def self.from_model(model, continuous: false)
@@ -40,10 +39,10 @@ module Cbc
       cols_idx = ccs.col_ptr.clone
       row_idx = 0
       end_row_idx = crs.row_ptr.size - 1
-      while row_idx < end_row_idx do
+      while row_idx < end_row_idx
         current_idx = crs.row_ptr[row_idx]
         last_idx = crs.row_ptr[row_idx + 1] - 1
-        while current_idx <= last_idx do
+        while current_idx <= last_idx
           col_idx = crs.col_idx[current_idx]
           ccs_col_idx = cols_idx[col_idx]
           cols_idx[col_idx] += 1
@@ -75,7 +74,6 @@ module Cbc
         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
 
@@ -85,13 +83,13 @@ module Cbc
       end
 
       idx = 0
-      while idx < @crs.nb_constraints do
+      while idx < @crs.nb_constraints
         c = @crs.model.constraints[idx]
         set_constraint_bounds(c, idx)
         idx += 1
       end
       idx = 0
-      while idx < ccs.nb_vars do
+      while idx < ccs.nb_vars
         v = @crs.model.vars[idx]
         if continuous
           Cbc_wrapper.Cbc_setContinuous(@cbc_model, idx)
@@ -111,10 +109,8 @@ module Cbc
       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)
@@ -198,12 +194,12 @@ module Cbc
       Cbc_wrapper.Cbc_writeMps(@cbc_model, "test")
     end
 
-  private
+    private
 
     def to_int_array(array)
       c_array = Cbc_wrapper::IntArray.new(array.size)
       idx = 0
-      while idx < array.size do
+      while idx < array.size
         c_array[idx] = array[idx]
         idx += 1
       end
@@ -214,7 +210,7 @@ module Cbc
     def to_double_array(array)
       c_array = Cbc_wrapper::DoubleArray.new(array.size)
       idx = 0
-      while idx < array.size do
+      while idx < array.size
         c_array[idx] = array[idx]
         idx += 1
       end

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

@@ -1,121 +1,123 @@
-module Util
-  class CompressedRowStorage
+module Cbc
+  module Util
+    class CompressedRowStorage
+      attr_accessor :model, :variable_index, :row_ptr, :col_idx, :values
 
-    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
+      def self.from_model(model)
+        new.tap do |crs|
+          crs.model = model
+          crs.make_variable_index
+          crs.fill_matrix
         end
-        crs.fill_matrix
       end
-    end
 
-    def nb_constraints
-      row_ptr.count - 1
-    end
+      def nb_constraints
+        row_ptr.size - 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)
+      def make_variable_index
+        indexes = @model.vars.size.times.to_a
+        @variable_index = model.vars.zip(indexes).to_h
+      end
 
-      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
+      def init_matrix
+        nb_values = model.constraints.map { |c| c.terms.size }.inject(:+) || 0
+        @row_ptr = Array.new(model.constraints.size)
+        @col_idx = Array.new(nb_values)
+        @values = Array.new(nb_values)
       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.clone
-        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]
-        crs.delete_missing_vars
+      def fill_matrix
+        init_matrix
+        nb_cols = 0
+        c_idx = 0
+        while c_idx < @model.constraints.size
+          constraint = @model.constraints[c_idx]
+          @row_ptr[c_idx] = nb_cols
+          nb_insert = constraint.terms.size
+          @col_idx[nb_cols, nb_insert] = constraint.terms.map { |term| variable_index[term.var] }
+          @values[nb_cols, nb_insert] = constraint.terms.map(&:mult)
+          nb_cols += nb_insert
+          c_idx += 1
+        end
+        @row_ptr << @col_idx.size
       end
-    end
 
-    def present_var_indices
-      is_present = Array.new(@variable_index.count, false)
-      @col_idx.each do |col_idx|
-        is_present[col_idx] = true
+      def restrict_to_n_constraints(nb_constraints)
+        length_of_values = @row_ptr[nb_constraints]
+        CompressedRowStorage.new.tap do |crs|
+          crs.model = @model.clone
+          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]
+          crs.delete_missing_vars
+        end
+      end
+
+      def present_var_indexes
+        present = Array.new(@variable_index.size, false)
+        @col_idx.each { |col_idx| present[col_idx] = true }
+        present
       end
-      is_present
-    end
 
-    def delete_missing_vars
-      at_least_one_missing = false
-      here = present_var_indices
-      new_idx = Array.new(@variable_index.count, -1)
-      idx = 0
-      current_index = 0
-      while idx < new_idx.size do
-        if here[idx]
+      def new_indexes
+        present = present_var_indexes
+        return nil if present.all?
+        new_idx = Array.new(@variable_index.size, -1)
+        current_index = 0
+        new_idx.size.times.each do |idx|
+          next unless present[idx]
           new_idx[idx] = current_index
           current_index += 1
-        else
-          at_least_one_missing = true
         end
-        idx += 1
+        new_idx
       end
 
-      return unless at_least_one_missing
-
-      new_variable_index = {}
-      @variable_index.each do |v, i|
-        new_variable_index[v] = new_idx[i] if new_idx[i] != -1
+      def change_indexes(new_idx)
+        new_variable_index = {}
+        @variable_index.each do |v, i|
+          new_variable_index[v] = new_idx[i] if new_idx[i] != -1
+        end
+        @variable_index = new_variable_index
       end
-      @variable_index = new_variable_index
-      @col_idx.map! { |idx| new_idx[idx] }
-      @model.vars = Array.new(@variable_index.size)
-      @variable_index.each do |var, idx|
-        @model.vars[idx] = var
+
+      def delete_missing_vars
+        new_idx = new_indexes
+        return if new_idx.nil?
+
+        change_indexes(new_idx)
+
+        @col_idx.map! { |i| new_idx[i] }
+        @model.vars = Array.new(@variable_index.size)
+        @variable_index.each { |var, i| @model.vars[i] = var }
       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
+      def move_constraint_to_start(range_idxs)
+        # Move in the model
+        constraints = model.constraints[range_idxs]
+        @model.constraints = @model.constraints.clone
+        @model.constraints[constraints.size, range_idxs.max] = model.constraints[0, range_idxs.min]
+        @model.constraints[0, constraints.size] = 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
+        # 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.size)..(range_idxs.max)).reverse_each do |idx|
+          @row_ptr[idx] = @row_ptr[idx - range_idxs.size] + nb_vars
+        end
+        @row_ptr[0, range_idxs.size] = new_begin
+        move_block_to_start(@col_idx, constraint_start_idx, nb_vars)
+        move_block_to_start(@values, constraint_start_idx, 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
+      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
 end

data/lib/ruby-cbc/version.rb

@@ -1,3 +1,3 @@
 module Cbc
-  VERSION = "0.3.10"
+  VERSION = "0.3.12"
 end

data/ruby-cbc.gemspec

@@ -28,5 +28,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "benchmark-ips"
   spec.add_development_dependency "ruby-prof"
 
-  spec.add_dependency "cbc-wrapper", '~> 2.9.7.2'
+  spec.add_dependency "cbc-wrapper", '~> 2.9.7.3'
 end