ruby-cbc 0.2.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d14f860956338d307ca81c97bdbffa02c18fa1fe
-  data.tar.gz: 8a6bccaf1dbfddb49b480763de807c9b9f5b4cc7
+  metadata.gz: def94f63dff658ab3ab9eeeccea2035d7d7e48b0
+  data.tar.gz: 69d3ebaa3e51a0d84bbd36ec51de60284146850a
 SHA512:
-  metadata.gz: 2c9262c9b81f0e9a56f9dad3aca561815e50fd664f5f4a94f55cc3f27a7fb975ca4e6857a3ae94498e1a02babe640c2bb56ec24f76825eb33af1a6ed833490bd
-  data.tar.gz: d6a23b5ba7347fbe5168a5a823f32e9a267e4a7e10dfaa596dbbb0fecb5802280c096a36a39b55d6bf506d19b81bd9e4dd7768a3075fe499bea8ca7589c5209e
+  metadata.gz: 9dc9707ea5aea3055b058a373e3490332f86d2ce2a7f3954bafd054dbce1f81d37dec5c72d7948cd20aa21e6353f6b76935af8aafe337c83a3d80dbfea699a14
+  data.tar.gz: 13daf4f282e9c9863a9c23d00c296924b0e7c30c31951343a43b6538953fa64e1126c0726b985e1cb6775f84ef84156cac2fd83a5ce8a0a9d9c660a6d3cd43db

data/README.md

@@ -1,6 +1,8 @@
 # Ruby-Cbc
 
-This gem wraps the Coin-Or Cbc Mixed Integer Linear Programming Library.
+This gem is using Cbc, an Integer Linear Programming Library, to provide optimization problems solving
+to ruby. With Ruby-Cbc, you can model you problem, solve it and find conflicts in case of infeasibility.
+
 It uses the version 2.9.7 of Cbc, and requires the version 2.9.7 of gem cbc-wrapper.
 
 ## Installation
@@ -102,6 +104,13 @@ model.enforce(x + 2 == y + 2)
 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
@@ -197,6 +206,24 @@ problem.best_bound      # Will tell you the best known bound
 problem.value_of(var)   # will tell you the computed value or a variable
 ```
 
+### Finding conflicts
+
+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)
+```
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/gverger/ruby-cbc.

data/lib/ruby-cbc/conflict_solver.rb

@@ -0,0 +1,59 @@
+module Cbc
+
+  class ConflictSolver
+
+    def initialize(model)
+     @model = model
+    end
+
+    # Assuming there is a conflict
+    def find_conflict
+      conflict_set = []
+      all_constraints = @model.constraints.to_a
+      loop do
+        m = Model.new
+        m.vars = @model.vars
+        m.enforce(conflict_set)
+        return conflict_set if infeasible?(m)
+
+        constraint = first_failing(conflict_set, all_constraints)
+        return conflict_set if !constraint
+
+        conflict_set << constraint
+      end
+    end
+
+  private
+    # finds the first constraint from constraints that makes the problem infeasible
+    def first_failing(conflict_set, constraints)
+      min_nb_constraints = 1
+      max_nb_constraints = constraints.count + 1
+
+      loop do
+        m = Model.new
+        m.vars = @model.vars
+        m.enforce(conflict_set)
+
+        nb_constraints = (max_nb_constraints + min_nb_constraints) / 2
+        m.enforce(constraints.take(nb_constraints))
+        if infeasible?(m)
+          max_nb_constraints = nb_constraints
+        else
+          min_nb_constraints = nb_constraints
+        end
+        if max_nb_constraints - min_nb_constraints <= 1
+          return nil if max_nb_constraints > constraints.count
+          return constraints[max_nb_constraints - 1]
+        end
+      end
+      # Shouldn't come here if the whole problem is infeasible
+      return nil
+    end
+
+    def infeasible?(model)
+      problem = model.to_problem
+      problem.solve
+      problem.proven_infeasible?
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ module Ilp
     GREATER_OR_EQ = :greater_or_eq
     EQUALS = :equals
 
-    attr_accessor :terms, :type, :bound
+    attr_accessor :terms, :type, :bound, :function_name
 
     def initialize(terms, type, bound)
       @terms = terms - bound
@@ -14,6 +14,14 @@ module Ilp
       @type = type
     end
 
+    def vars
+      terms.vars.uniq
+    end
+
+    def to_function_s
+      "#{function_name || 'constraint'}(#{vars.join(', ')})"
+    end
+
     def to_s
       case @type
       when LESS_OR_EQ

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

@@ -41,7 +41,7 @@ module Ilp
       @terms = []
       constant ||= 0
       @terms << constant
-      hterms.each do |v, ts| 
+      hterms.each do |v, ts|
         t = ts.inject(Ilp::Term.new(v, 0)) { |v1, v2| v1.mult += v2.mult; v1 }
         terms << t if t.mult != 0
       end
@@ -72,6 +72,10 @@ module Ilp
       @terms.map(&:to_s).join(' ')
     end
 
+    def vars
+      @terms.map(&:var)
+    end
+
   private
     # Must be normalized!
     def pop_constant

data/lib/ruby-cbc/model.rb

@@ -40,8 +40,21 @@ module Cbc
       array_var(length, Ilp::Var::CONTINUOUS_KIND, range, names)
     end
 
-    def enforce(constraint)
-      constraints << constraint
+    def enforce(*constraints)
+      constraints.each do |constraint|
+        if constraint.instance_of? Ilp::Constraint
+          self.constraints << constraint
+        elsif constraint.instance_of? Array
+          self.constraints += constraint
+        elsif constraint.instance_of? Hash
+          constraint.each do |name, c|
+            self.constraints << c
+            c.function_name = name.to_s
+          end
+        else
+          puts "Not a constraint: #{constraint}"
+        end
+      end
     end
 
     def minimize(expression)
@@ -109,13 +122,13 @@ module Cbc
       v
     end
 
-    def lb_to_s(lb) 
+    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) 
+    def ub_to_s(ub)
       return "+inf" if ! ub || ub == Cbc::INF
       return "-inf" if ub == -Cbc::INF
       return "#{ub}"

data/lib/ruby-cbc/problem.rb

@@ -1,12 +1,14 @@
 module Cbc
   class Problem
 
+    attr_reader :model
 
     def initialize(model)
 
       @int_arrays = []
       @double_arrays = []
 
+      @model = model
       @variables = {}
       vars = model.vars
       vars_data = {}
@@ -137,6 +139,14 @@ module Cbc
       Cbc_wrapper.Cbc_getBestPossibleObjValue(@cbc_model)
     end
 
+    def find_conflict
+      @conflict_set ||= ConflictSolver.new(model).find_conflict
+    end
+
+    def find_conflict_vars
+      @conflict_vars ||= find_conflict.map(&:vars).flatten.uniq
+    end
+
     def self.finalizer(cbc_model, int_arrays, double_arrays)
       proc do
         Cbc_wrapper.Cbc_deleteModel(cbc_model)

data/lib/ruby-cbc/version.rb

@@ -1,3 +1,3 @@
 module Cbc
-  VERSION = "0.2.5"
+  VERSION = "0.3.0"
 end

data/lib/ruby-cbc.rb

@@ -5,6 +5,7 @@ module Cbc
 end
 
 files = %w(
+conflict_solver
 model
 problem
 version

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-cbc
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.0
 platform: ruby
 authors:
 - Guillaume Verger
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-01-19 00:00:00.000000000 Z
+date: 2016-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -125,6 +125,7 @@ files:
 - bin/console
 - bin/setup
 - lib/ruby-cbc.rb
+- lib/ruby-cbc/conflict_solver.rb
 - lib/ruby-cbc/ilp/constant.rb
 - lib/ruby-cbc/ilp/constraint.rb
 - lib/ruby-cbc/ilp/objective.rb