gecoder 0.3.0 → 0.4.0

data/specs/constraints/domain.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
+
+describe Gecode::Constraints::Int::Domain do
+  before do
+    @model = Gecode::Model.new
+    @domain = 0..3
+    @x = @model.int_var(@domain)
+    @range_domain = 1..2
+    @three_dot_range_domain = 1...2
+    @non_range_domain = [1, 3]
+    
+    @invoke_options = lambda do |hash| 
+      @x.must_be.in(@non_range_domain, hash) 
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      if reif_var.nil?
+        Gecode::Raw.should_receive(:dom).once.with(@model.active_space, 
+          @x.bind, an_instance_of(Gecode::Raw::IntSet), strength)
+      else
+        Gecode::Raw.should_receive(:dom).once.with(@model.active_space, 
+          @x.bind, an_instance_of(Gecode::Raw::IntSet), 
+          an_instance_of(Gecode::Raw::BoolVar), strength)
+      end
+    end
+  end
+  
+  it 'should translate domain constraints with range domains' do
+    Gecode::Raw.should_receive(:dom).once.with(@model.active_space, 
+      @x.bind, @range_domain.first, @range_domain.last, Gecode::Raw::ICL_DEF)
+    @x.must_be.in @range_domain
+    @model.solve!
+  end
+
+  it 'should translate domain constraints with three dot range domains' do
+    Gecode::Raw.should_receive(:dom).once.with(@model.active_space, 
+      @x.bind, @three_dot_range_domain.first, @three_dot_range_domain.last, 
+      Gecode::Raw::ICL_DEF)
+    @x.must_be.in @three_dot_range_domain
+    @model.solve!
+  end
+  
+  it 'should translate domain constraints with non-range domains' do
+    @expect_options.call(Gecode::Raw::ICL_DEF, nil)
+    @invoke_options.call({})
+  end
+  
+  it 'should handle negation' do
+    @x.must_not_be.in @range_domain
+    @model.solve!
+    @x.should have_domain(@domain.to_a - @range_domain.to_a)
+  end
+  
+  it_should_behave_like 'constraint with options'
+end

data/specs/constraints/element.rb

@@ -0,0 +1,128 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
+
+class ElementSampleProblem < Gecode::Model
+  attr :prices
+  attr :store
+  attr :price
+  attr :fixnum_prices
+  
+  def initialize
+    prices = [17, 63, 45, 63]
+    @fixnum_prices = wrap_enum(prices)
+    @prices = int_var_array(4, *prices)
+    @store = int_var(0...prices.size)
+    @price = int_var(*prices)
+    branch_on wrap_enum([@store])
+  end
+end
+
+describe Gecode::Constraints::IntEnum::Element do
+  before do
+    @model = ElementSampleProblem.new
+    @prices = @model.prices
+    @price = @model.price
+    @store = @model.store
+    @fixnum_prices = @model.fixnum_prices
+    
+    # For constraint option spec.
+    @invoke_options = lambda do |hash| 
+      @prices[@store].must_be.greater_than(@price, hash) 
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      if reif_var.nil?
+        Gecode::Raw.should_receive(:element).once.with(@model.active_space, 
+          an_instance_of(Gecode::Raw::IntVarArray), 
+          an_instance_of(Gecode::Raw::IntVar),
+          an_instance_of(Gecode::Raw::IntVar), an_instance_of(Fixnum))
+        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+          an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_GR,
+          an_instance_of(Gecode::Raw::IntVar), strength)
+      else
+        Gecode::Raw.should_receive(:element).once.with(@model.active_space, 
+          an_instance_of(Gecode::Raw::IntVarArray), 
+          an_instance_of(Gecode::Raw::IntVar),
+          an_instance_of(Gecode::Raw::IntVar), an_instance_of(Fixnum))
+        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+          an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_GR,
+          an_instance_of(Gecode::Raw::IntVar), 
+          an_instance_of(Gecode::Raw::BoolVar), strength)
+      end
+    end
+  end
+  
+  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
+    it "should translate #{relation} with variable right hand side" do
+      Gecode::Raw.should_receive(:element).once.with(@model.active_space, 
+        an_instance_of(Gecode::Raw::IntVarArray), 
+        an_instance_of(Gecode::Raw::IntVar),
+        an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::ICL_DEF)
+      unless type == Gecode::Raw::IRT_EQ
+        Gecode::Raw.should_receive(:rel).once.with(@model.active_space,
+          an_instance_of(Gecode::Raw::IntVar), type,
+          an_instance_of(Gecode::Raw::IntVar), an_instance_of(Fixnum))
+      end
+      @prices[@store].must.send(relation, @price)
+      @model.solve!
+    end
+  end
+
+  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate negated #{relation} with variable right hand side" do
+      Gecode::Raw.should_receive(:element).once.with(@model.active_space, 
+        an_instance_of(Gecode::Raw::IntVarArray), 
+        an_instance_of(Gecode::Raw::IntVar),
+        an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::ICL_DEF)
+      Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+        an_instance_of(Gecode::Raw::IntVar), type,
+        an_instance_of(Gecode::Raw::IntVar), an_instance_of(Fixnum))
+      @prices[@store].must_not.send(relation, @price)
+      @model.solve!
+    end
+  end
+  
+  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
+    it "should translate #{relation} with constant right hand side" do
+      Gecode::Raw.should_receive(:element).once.with(@model.active_space, 
+        an_instance_of(Gecode::Raw::IntVarArray), 
+        an_instance_of(Gecode::Raw::IntVar),
+        an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::ICL_DEF)
+      unless type == Gecode::Raw::IRT_EQ
+        Gecode::Raw.should_receive(:rel).once.with(@model.active_space,
+          an_instance_of(Gecode::Raw::IntVar), type, 5, an_instance_of(Fixnum))
+      end
+      @prices[@store].must.send(relation, 5)
+      @model.solve!
+    end
+  end
+
+  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate negated #{relation} with constant right hand side" do
+      Gecode::Raw.should_receive(:element).once.with(@model.active_space, 
+        an_instance_of(Gecode::Raw::IntVarArray), 
+        an_instance_of(Gecode::Raw::IntVar),
+        an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::ICL_DEF)
+      Gecode::Raw.should_receive(:rel).once.with(@model.active_space,
+        an_instance_of(Gecode::Raw::IntVar), type, 5, an_instance_of(Fixnum))
+      @prices[@store].must_not.send(relation, 5)
+      @model.solve!
+    end
+  end
+
+  it 'should not disturb normal array access' do
+    @fixnum_prices[2].should_not be_nil
+    @prices[2].should_not be_nil
+  end
+
+  it 'should handle fixnum enums as enumeration' do
+    @fixnum_prices[@store].must == @fixnum_prices[2]
+    @model.solve!.store.val.should equal(2)
+  end
+
+  it 'should raise error on right hand sides of the wrong type' do
+    lambda{ @prices[@store].must == 'hello' }.should raise_error(TypeError) 
+  end
+  
+  it_should_behave_like 'constraint with options'
+end

data/specs/constraints/equality.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
+
+describe Gecode::Constraints::IntEnum::Equality do
+  before do
+    @model = Gecode::Model.new
+    @vars = @model.int_var_array(4, -2..2)
+    @invoke_options = lambda do |hash| 
+      @vars.must_be.equal(hash)
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      Gecode::Raw.should_receive(:eq).once.with(@model.active_space, 
+        anything, strength)
+    end
+  end
+  
+  it 'should translate equality constraints' do
+    @expect_options.call(Gecode::Raw::ICL_DEF, nil)
+    @invoke_options.call({})
+    @vars.must_be.equal
+  end
+
+  it 'should not allow negation' do
+    lambda{ @vars.must_not_be.equal }.should raise_error(
+      Gecode::MissingConstraintError)
+  end
+  
+  it_should_behave_like 'constraint with strength option'
+end

data/specs/constraints/linear.rb

@@ -0,0 +1,166 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
+
+class LinearSampleProblem < Gecode::Model
+  attr :x
+  attr :y
+  attr :z
+  
+  def initialize(x_dom, y_dom, z_dom)
+    @x = self.int_var(x_dom)
+    @y = self.int_var(y_dom)
+    @z = self.int_var(z_dom)
+    branch_on wrap_enum([@x, @y, @z])
+  end
+end
+
+describe Gecode::Constraints::Int::Linear do
+  before do
+    @x_dom = 0..2
+    @y_dom = -3..3
+    @z_dom = 0..10
+    @model = LinearSampleProblem.new(@x_dom, @y_dom, @z_dom)
+    @x = @model.x
+    @y = @model.y
+    @z = @model.z
+    
+    # For constraint option spec.
+    @invoke_options = lambda do |hash| 
+      (@x + @y).must_be.greater_than(@z, hash)
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      # TODO: this is hard to spec from this level.
+    end
+  end
+
+  it 'should handle addition with a variable' do
+    (@x + @y).must == 0
+    sol = @model.solve!
+    x = sol.x.val
+    y = sol.y.val
+    (x + y).should be_zero
+  end
+  
+  it 'should handle addition with multiple variables' do
+    (@x + @y + @z).must == 0
+    sol = @model.solve!
+    x = sol.x.val
+    y = sol.y.val
+    z = sol.z.val
+    (x + y + z).should be_zero
+  end
+  
+  it 'should handle subtraction with a variable' do
+    (@x - @y).must == 0
+    sol = @model.solve!
+    x = sol.x.val
+    y = sol.y.val
+    (x - y).should be_zero
+  end
+  
+  it 'should handle non-zero constants as right hand side' do
+    (@x + @y).must == 1
+    sol = @model.solve!
+    x = sol.x.val
+    y = sol.y.val
+    (x + y).should equal(1)
+  end
+  
+  it 'should handle variables as right hand side' do
+    (@x + @y).must == @z
+    sol = @model.solve!
+    x = sol.x.val
+    y = sol.y.val
+    z = sol.z.val
+    (x + y).should equal(z)
+  end
+  
+  it 'should handle linear expressions as right hand side' do
+    (@x + @y).must == @z + @y
+    sol = @model.solve!
+    x = sol.x.val
+    y = sol.y.val
+    z = sol.z.val
+    (x + y).should equal(z + y)
+  end
+  
+  it 'should raise error on invalid right hand sides' do
+    lambda{ ((@x + @y).must == 'z') }.should raise_error(TypeError) 
+  end
+  
+  it 'should handle coefficients other than 1' do
+    (@x * 2 + @y).must == 0
+    sol = @model.solve!
+    x = sol.x.val
+    y = sol.y.val
+    (2*x + y).should equal(0)
+  end
+  
+  it 'should handle addition with constants' do
+    (@y + 2).must == 1
+    sol = @model.solve!
+    y = sol.y.val
+    (y + 2).should equal(1)
+  end
+  
+  it 'should handle subtraction with a constant' do
+    (@x - 2).must == 0
+    sol = @model.solve!
+    x = sol.x.val
+    (x - 2).should be_zero
+  end
+  
+  it 'should a single variable as left hande side' do
+    @x.must == @y + @z
+    sol = @model.solve!
+    x = sol.x.val
+    y = sol.y.val
+    z = sol.z.val
+    x.should equal(y + z)
+  end
+  
+  it 'should handle parenthesis' do
+    (@x - (@y + @z)).must == 1
+    sol = @model.solve!
+    x = sol.x.val
+    y = sol.y.val
+    z = sol.z.val
+    (x - (y + z)).should equal(1)
+  end
+  
+  it 'should handle multiplication of parenthesis' do
+    (((@x + @y*10)*10 + @z)*10).must == 0
+    sol = @model.solve!
+    x = sol.x.val
+    y = sol.y.val
+    z = sol.z.val
+    (((x + y*10)*10 + z)*10).should equal(0)
+  end
+  
+  relations = ['>', '>=', '<', '<=', '==']
+  
+  relations.each do |relation|
+    it "should handle #{relation} with constant integers" do
+      (@x + @y).must.send(relation, 1)
+      sol = @model.solve!
+      sol.should_not be_nil
+      (sol.x.val + sol.y.val).should.send(relation, 1)
+    end
+  end
+  
+  relations.each do |relation|
+    it "should handle negated #{relation} with constant integers" do
+      (@x + @y).must_not.send(relation, 1)
+      sol = @model.solve!
+      sol.should_not be_nil
+      (sol.x.val + sol.y.val).should_not.send(relation, 1)
+    end
+  end
+  
+  it 'should not interfere with other defined multiplication methods' do
+    (@x * :foo).should be_nil
+  end
+  
+  it_should_behave_like 'constraint with options'
+end

data/specs/constraints/reification_sugar.rb

@@ -0,0 +1,92 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class ReifSugarSampleProblem < Gecode::Model
+  attr :x
+  attr :y
+  attr :z
+  
+  def initialize
+    @x = int_var(0..1)
+    @y = int_var(1..2)
+    @z = int_var(3..4)
+    branch_on wrap_enum([@x, @y, @z])
+  end
+end
+
+describe Gecode::Constraints::ReifiableConstraint do
+  before do
+    @model = ReifSugarSampleProblem.new
+    @x = @model.x
+    @y = @model.y
+    @z = @model.z
+  end
+
+  it 'should fail disjunctions if neither side can be satisfied' do
+    (@x.must == 3) | (@y.must == 3)
+    @model.solve!.should be_nil
+  end
+  
+  it 'should translate disjunctions' do
+    Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+      an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_GR, 0, 
+      an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::ICL_DEF)
+    Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+      an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_EQ, 3, 
+      an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::ICL_DEF)
+    (@x.must > 0) | (@y.must == 3)
+    sol = @model.solve!
+  end
+  
+  it 'should solve disjunctions' do
+    (@x.must > 0) | (@y.must == 3)
+    sol = @model.solve!
+    sol.should_not be_nil
+    sol.x.should have_domain([1])
+  end
+  
+  it 'should fail conjunctions if one side can\'t be satisfied' do
+    (@x.must > 3) & (@y.must == 3)
+    @model.solve!.should be_nil
+  end
+  
+  it 'should translate conjunctions' do
+    Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+      an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_GR, 0, 
+      an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::ICL_DEF)
+    Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+      an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_EQ, 2, 
+      an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::ICL_DEF)
+    (@x.must > 0) & (@y.must == 2)
+    sol = @model.solve!
+  end
+  
+  it 'should solve conjunctions' do
+    (@x.must > 0) & (@y.must == 2)
+    sol = @model.solve!
+    sol.should_not be_nil
+    sol.x.should have_domain([1])
+    sol.y.should have_domain([2])
+  end
+
+  it 'should handle the same variable being used multiple times' do
+    (@z.must == 4) | (@z.must == 4)
+    sol = @model.solve!
+    sol.should_not be_nil
+    sol.z.should have_domain([4])
+  end
+  
+  it 'should handle nested operations' do
+    ((@x.must > 3) & (@y.must == 2)) | (@z.must == 4) | (
+      (@x.must == 0) & (@z.must == 4))
+    sol = @model.solve!
+    sol.should_not be_nil
+    sol.x.should have_domain([0])
+    sol.z.should have_domain([4])
+  end
+  
+  it 'should handle negations' do
+    (@z.must_not == 4) & (@z.must == 4)
+    sol = @model.solve!
+    sol.should be_nil
+  end
+end

data/specs/constraints/relation.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
+
+describe Gecode::Constraints::Int::Linear, ' (simple ones)' do
+  before do
+    @model = Gecode::Model.new
+    @x = @model.int_var(1..2)
+    @int = 4
+    @y = @model.int_var(1..2)
+    
+    # For constraint option spec.
+    @invoke_options = lambda do |hash| 
+      @x.must_be.greater_than(3, hash) 
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      if reif_var.nil?
+        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+          anything, Gecode::Raw::IRT_GR, anything, 
+          strength)
+      else
+        Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+          an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_GR, anything, 
+          an_instance_of(Gecode::Raw::BoolVar), strength)
+      end
+    end
+  end
+  
+  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
+    it "should translate #{relation} with constant to simple relation" do
+      Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+        an_instance_of(Gecode::Raw::IntVar), type, @int, Gecode::Raw::ICL_DEF)
+      @x.must.send(relation, @int)
+      @model.solve!
+    end
+  end
+
+  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate negated #{relation} with constant to simple relation" do
+      Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+        an_instance_of(Gecode::Raw::IntVar), type, @int, Gecode::Raw::ICL_DEF)
+      @x.must_not.send(relation, @int)
+      @model.solve!
+    end
+  end
+
+  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
+    it "should translate #{relation} with variables to simple relation" do
+      Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+        an_instance_of(Gecode::Raw::IntVar), type, 
+        an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::ICL_DEF)
+      @x.must.send(relation, @y)
+      @model.solve!
+    end
+  end
+
+  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate negated #{relation} with variable to simple relation" do
+      Gecode::Raw.should_receive(:rel).once.with(@model.active_space, 
+        an_instance_of(Gecode::Raw::IntVar), type, 
+        an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::ICL_DEF)
+      @x.must_not.send(relation, @y)
+      @model.solve!
+    end
+  end
+
+  it 'should raise error on arguments of the wrong type' do
+    lambda{ @x.must == 'hello' }.should raise_error(TypeError) 
+  end
+  
+  it_should_behave_like 'constraint with options'
+end