ruby-cbc 0.3.10 → 0.3.12

data/README.md

@@ -1,3 +1,4 @@
+[![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
@@ -120,7 +121,7 @@ a1 * x1 + a2 * x2 + ... + an * xn == C
 
 With Ruby-Cbc you can write
 ```ruby
-2 * (2 + 5 * x) + 4 * 5 + 1 == 1 + 4 * 5
+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 !
 

data/lib/ruby-cbc.rb

@@ -1,21 +1,21 @@
 require "ruby-cbc/version"
-require 'cbc-wrapper'
+require "cbc-wrapper"
 
 module Cbc
 end
 
 files = %w(
-conflict_solver
-model
-problem
-version
-ilp/constant
-ilp/constraint
-ilp/objective
-ilp/term
-ilp/term_array
-ilp/var
-utils/compressed_row_storage
+  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|

data/lib/ruby-cbc/conflict_solver.rb

@@ -1,7 +1,5 @@
 module Cbc
-
   class ConflictSolver
-
     def initialize(problem)
       # clone the model minus the objective
       @model = Model.new
@@ -12,7 +10,7 @@ module Cbc
 
     def find_conflict
       crs = Util::CompressedRowStorage.from_model(@model)
-      continuous = is_continuous_conflict?(crs)
+      continuous = continuous_conflict?(crs)
       unless continuous
         p = Problem.from_compressed_row_storage(crs, continuous: false)
         return [] unless infeasible?(p)
@@ -57,12 +55,13 @@ module Cbc
       crs.model.constraints[0, conflict_set_size]
     end
 
-    def is_continuous_conflict?(crs)
+    def continuous_conflict?(crs)
       problem = Problem.from_compressed_row_storage(crs, continuous: true)
       infeasible?(problem)
     end
 
-  private
+    private
+
     # finds the first constraint from constraints that makes the problem infeasible
     def first_failing(conflict_set_size, crs, continuous: false, max_iterations: nil)
       min_idx = conflict_set_size

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

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

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

@@ -1,6 +1,5 @@
 module Ilp
   class Constraint
-
     LESS_OR_EQ = :less_or_eq
     GREATER_OR_EQ = :greater_or_eq
     EQUALS = :equals
@@ -15,26 +14,22 @@ module Ilp
     end
 
     def vars
-      terms.vars.uniq
+      terms.vars
     end
 
     def to_function_s
-      "#{function_name || 'constraint'}(#{vars.map(&:name).join(', ')})"
+      "#{function_name || 'constraint'}(#{vars.map!(&:name).join(', ')})"
     end
 
+    SIGN_TO_STRING = {
+      LESS_OR_EQ => "<=",
+      GREATER_OR_EQ => ">=",
+      EQUALS => "=="
+    }
+
     def to_s
-      case @type
-      when LESS_OR_EQ
-        sign = '<='
-      when GREATER_OR_EQ
-        sign = '>='
-      when EQUALS
-        sign = '='
-      else
-        sign = '??'
-      end
-      "#{@terms.to_s} #{sign} #{@bound}"
+      sign = SIGN_TO_STRING(@type) || "??"
+      "#{@terms} #{sign} #{@bound}"
     end
-
   end
 end

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

@@ -1,6 +1,5 @@
 module Ilp
   class Objective
-
     MINIMIZE = :min
     MAXIMIZE = :max
 
@@ -10,17 +9,12 @@ module Ilp
       @terms = Ilp::Term.new(@terms) if @terms.is_a? Ilp::Var
       @terms = Ilp::TermArray.new([@terms]) if @terms.is_a? Ilp::Term
       @terms.normalize!
-      cste = @terms.send(:pop_constant)
-      puts "Removing constant [#{cste}] in objective" if cste != 0
+      @terms.send(:pop_constant)
       @objective_function = objective_function
     end
 
     def to_s
-      str = ""
-      str << (@objective_function == :max ? "Maximize" : "Minimize")
-      str << "\n  "
-      str << terms.to_s
+      "#{(@objective_function == :max ? 'Maximize' : 'Minimize')}\n  #{terms}"
     end
-
   end
 end

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

@@ -1,6 +1,5 @@
 module Ilp
   class Term
-
     attr_accessor :mult, :var
 
     def initialize(var, mult = 1)
@@ -8,30 +7,29 @@ module Ilp
       @var = var
     end
 
-    def +(vars)
-      Ilp::TermArray.new([self]) + vars
+    def +(other)
+      Ilp::TermArray.new([self]) + other
     end
 
-    def -(vars)
-      Ilp::TermArray.new([self]) - vars
+    def -(other)
+      Ilp::TermArray.new([self]) - other
     end
 
-    def ==(vars)
-      Ilp::TermArray.new([self]) == vars
+    def ==(other)
+      Ilp::TermArray.new([self]) == other
     end
 
-    def <=(vars)
-      Ilp::TermArray.new([self]) <= vars
+    def <=(other)
+      Ilp::TermArray.new([self]) <= other
     end
 
-    def >=(vars)
-      Ilp::TermArray.new([self]) >= vars
+    def >=(other)
+      Ilp::TermArray.new([self]) >= other
     end
 
-
-    def *(mult)
-      raise ArgumentError, 'Argument is not numeric' unless mult.is_a? Numeric
-      Ilp::Term.new(@var, @mult * mult)
+    def *(other)
+      raise ArgumentError, "Argument is not numeric" unless other.is_a? Numeric
+      Ilp::Term.new(@var, @mult * other)
     end
 
     def coerce(num)

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

@@ -1,86 +1,87 @@
 module Ilp
   class TermArray
-    include Enumerable
+    extend Forwardable
 
     attr_accessor :terms
+    def_delegators :@terms, :map, :each, :size
 
     def initialize(terms)
       @terms = terms
     end
 
-    def +(vars)
+    def +(other)
       new_terms = terms.dup
-      if vars.is_a? Numeric
-        new_terms << vars
-      elsif vars.is_a? Ilp::Var
-        new_terms << Ilp::Term.new(vars)
-      elsif vars.is_a? Ilp::Term
-        new_terms << vars
-      elsif vars.is_a? Ilp::TermArray
-        new_terms.concat(vars.terms)
+      case other
+      when Numeric
+        new_terms << other
+      when Ilp::Var
+        new_terms << Ilp::Term.new(other)
+      when Ilp::Term
+        new_terms << other
+      when Ilp::TermArray
+        new_terms.concat(other.terms)
       else
-        raise ArgumentError, "Argument is not allowed: #{vars} of type #{vars.class}"
+        raise ArgumentError, "Argument is not allowed: #{other} of type #{other.class}"
       end
       TermArray.new(new_terms)
     end
 
-    def -(vars)
-      self + -1 * vars
+    def -(other)
+      self + -1 * other
     end
 
-    def *(mult)
-      raise ArgumentError, 'Argument is not numeric' unless mult.is_a? Numeric
-      new_terms = terms.map { |term| term * mult }
+    def *(other)
+      raise ArgumentError, 'Argument is not numeric' unless other.is_a? Numeric
+      new_terms = terms.map { |term| term * other }
       TermArray.new(new_terms)
     end
 
     # cste + nb * var + nb * var...
     def normalize!
-      constant = @terms.select{ |t| t.is_a? Numeric }.reduce(:+)
-      hterms = @terms.select{ |t| t.is_a? Ilp::Term }.group_by(&:var)
-      @terms = []
-      constant ||= 0
-      @terms << constant
-      reduced = hterms.map do |v, ts|
-        if ts.count == 1
-          ts.first
-        else
-          ts.reduce(Ilp::Term.new(v, 0)) { |v1, v2| v1.mult += v2.mult; v1 }
+      constant = 0
+      hterms = {}
+      @terms.each do |term|
+        case term
+        when Numeric
+          constant += term
+        when Ilp::Term
+          v = term.var
+          hterms[v] ||= Ilp::Term.new(v, 0)
+          hterms[v].mult += term.mult
         end
-      end.reject { |term| term.mult == 0 }
-      @terms.concat reduced
+      end
+      reduced = hterms.map { |_, term| term unless term.mult.zero? }
+      reduced.compact!
+      @terms = [constant].concat reduced
       self
     end
 
-    def <=(value)
-      Ilp::Constraint.new(self, Ilp::Constraint::LESS_OR_EQ, value)
+    def <=(other)
+      Ilp::Constraint.new(self, Ilp::Constraint::LESS_OR_EQ, other)
     end
 
-    def >=(value)
-      Ilp::Constraint.new(self, Ilp::Constraint::GREATER_OR_EQ, value)
+    def >=(other)
+      Ilp::Constraint.new(self, Ilp::Constraint::GREATER_OR_EQ, other)
     end
 
-    def ==(value)
-      Ilp::Constraint.new(self, Ilp::Constraint::EQUALS, value)
+    def ==(other)
+      Ilp::Constraint.new(self, Ilp::Constraint::EQUALS, other)
     end
 
     def coerce(value)
       [Ilp::Constant.new(value), self]
     end
 
-    def each(&block)
-      @terms.each(&block)
-    end
-
     def to_s
-      @terms.map(&:to_s).join(' ')
+      @terms.map(&:to_s).join(" ")
     end
 
     def vars
       @terms.map(&:var)
     end
 
-  private
+    private
+
     # Must be normalized!
     def pop_constant
       terms.slice!(0)

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

@@ -9,7 +9,7 @@ module Ilp
     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?
+      @name = ("a".."z").to_a.sample(8).join if name.nil?
       @lower_bound = lower_bound
       @upper_bound = upper_bound
     end
@@ -23,32 +23,32 @@ module Ilp
       @lower_bound..@upper_bound
     end
 
-    def +(vars)
-      Ilp::Term.new(self) + vars
+    def +(other)
+      Ilp::Term.new(self) + other
     end
 
-    def -(vars)
-      Ilp::Term.new(self) - vars
+    def -(other)
+      Ilp::Term.new(self) - other
     end
 
     def -@
       Ilp::Term.new(self, -1)
     end
 
-    def *(mult)
-      Ilp::Term.new(self) * mult
+    def *(other)
+      Ilp::Term.new(self) * other
     end
 
-    def ==(vars)
-      Ilp::Term.new(self) == vars
+    def ==(other)
+      Ilp::Term.new(self) == other
     end
 
-    def <=(vars)
-      Ilp::Term.new(self) <= vars
+    def <=(other)
+      Ilp::Term.new(self) <= other
     end
 
-    def >=(vars)
-      Ilp::Term.new(self) >= vars
+    def >=(other)
+      Ilp::Term.new(self) >= other
     end
 
     def coerce(num)
@@ -56,7 +56,7 @@ module Ilp
     end
 
     def to_s
-      name
+      name.to_s
     end
   end
 end