gecoder-with-gecode 0.8.3 → 0.9.0

data/specs/constraints/int/relation.rb

@@ -0,0 +1,84 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+Gecode::Util::RELATION_TYPES.each_pair do |relation, rel_value|
+  describe Gecode::Int::Relation, " (#{relation} with int op)" do
+    before do
+      @model = Gecode::Model.new
+      
+      # For constraint spec.
+      @types = [:int, :int]
+      @invoke = lambda do |receiver, op, hash| 
+        receiver.method(relation).call(op, hash) 
+        @model.solve!
+      end
+      @expect = lambda do |var1, var2, opts, reif_var|
+        if reif_var.nil?
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            var1, rel_value, var2, *opts)
+        else
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            var1, rel_value, var2, reif_var, *opts)
+        end
+      end
+    end
+    
+    it "should constrain the #{relation} with an int operand" do
+      ints = @model.int_var_array(2, -5..5)
+      @model.branch_on ints
+      int1, int2 = ints
+      int1.must.method(relation).call(int2)
+      @model.solve!
+      int1.value.should.method(relation).call(int2.value)
+    end
+
+    it "should constrain the negated #{relation} with an int operand" do
+      ints = @model.int_var_array(2, -5..5)
+      @model.branch_on ints
+      int1, int2 = ints
+      int1.must_not.method(relation).call(int2)
+      @model.solve!
+      int1.value.should_not.method(relation).call(int2.value)
+    end
+
+    it_should_behave_like 'reifiable constraint'
+  end
+end
+
+Gecode::Util::RELATION_TYPES.each_pair do |relation, rel_value|
+  describe Gecode::Int::Relation, " (#{relation} with fixnum)" do
+    before do
+      @model = Gecode::Model.new
+      
+      # For constraint spec.
+      @types = [:int]
+      @invoke = lambda do |receiver, hash| 
+        receiver.method(relation).call(17, hash) 
+        @model.solve!
+      end
+      @expect = lambda do |var, opts, reif_var|
+        if reif_var.nil?
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            var, rel_value, 17, *opts)
+        else
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            var, rel_value, 17, reif_var, *opts)
+        end
+      end
+    end
+
+    it "should constrain the #{relation} with a fixnum" do
+      int = @model.int_var(-5..5)
+      @model.branch_on int
+      int.must.method(relation).call(3)
+      @model.solve!
+      int.value.should.method(relation).call(3)
+    end
+    
+    it_should_behave_like 'reifiable constraint'
+  end
+end
+

data/specs/constraints/int_enum/arithmetic.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/../property_helper'
+
+class IntEnumArithmeticSampleProblem < Gecode::Model
+  attr :numbers
+  attr :var
+  
+  def initialize
+    @numbers = int_var_array(4, 0..9)
+    @var = int_var(-9..9)
+    branch_on @numbers
+    branch_on @var
+  end
+end
+
+describe Gecode::IntEnum::Arithmetic, ' (max)' do
+  before do
+    @model = IntEnumArithmeticSampleProblem.new
+    @numbers = @model.numbers
+    @var = @model.var
+
+    @property_types = [:int_enum]
+    @select_property = lambda do |int_enum|
+      int_enum.max
+    end
+    @selected_property = @numbers.max
+    @constraint_class = Gecode::BlockConstraint
+  end
+  
+  it 'should constrain the maximum value' do
+    @numbers.max.must > 5
+    @model.solve!.numbers.values.max.should > 5
+  end
+
+  it 'should translate into a max constraint' do
+    Gecode::Raw.should_receive(:max)
+    @numbers.max.must == 5
+    @model.solve!
+  end
+  
+  it_should_behave_like(
+    'property that produces int operand by short circuiting equality')
+end
+
+describe Gecode::IntEnum::Arithmetic, ' (min)' do
+  before do
+    @model = IntEnumArithmeticSampleProblem.new
+    @numbers = @model.numbers
+    @var = @model.var
+
+    @property_types = [:int_enum]
+    @select_property = lambda do |int_enum|
+      int_enum.min
+    end
+    @selected_property = @numbers.min
+    @constraint_class = Gecode::BlockConstraint
+  end
+  
+  it 'should constrain the minimum value' do
+    @numbers.min.must > 5
+    @model.solve!.numbers.values.min.should > 5
+  end
+
+  it 'should translate into a min constraint' do
+    Gecode::Raw.should_receive(:min)
+    @numbers.min.must == 5
+    @model.solve!
+  end
+  
+  it_should_behave_like(
+    'property that produces int operand by short circuiting equality')
+end
+

data/specs/constraints/int_enum/channel.rb

@@ -0,0 +1,57 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+class ChannelSampleProblem < Gecode::Model
+  attr :elements
+  attr :positions
+  attr :sets
+  
+  def initialize
+    @elements = int_var_array(4, 0..3)
+    @elements.must_be.distinct
+    @positions = int_var_array(4, 0..3)
+    @positions.must_be.distinct
+    @sets = set_var_array(4, [], 0..3)
+    branch_on @positions
+  end
+end
+
+describe Gecode::IntEnum::Channel, ' (two int enums)' do
+  before do
+    @model = ChannelSampleProblem.new
+    @positions = @model.positions
+    @elements = @model.elements
+
+    @types = [:int_enum, :int_enum]
+    @invoke = lambda do |receiver, int_enum, hash| 
+      receiver.channel(int_enum, hash)
+      @model.solve!
+    end
+    @expect = lambda do |var1, var2, opts, reif_var|
+      Gecode::Raw.should_receive(:channel).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        var1, var2, *opts)
+    end
+  end
+
+  it 'should translate into a channel constraint' do
+    Gecode::Raw.should_receive(:channel).once.with(
+      an_instance_of(Gecode::Raw::Space), 
+      anything, anything, Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF)
+    @positions.must.channel @elements
+    @model.solve!
+  end
+
+  it 'should constrain variables to be channelled' do
+    @elements.must.channel @positions
+    @model.solve!
+    elements = @model.elements.values
+    positions = @model.elements.values
+    elements.each_with_index do |element, i|
+      element.should equal(positions.index(i))
+    end
+  end
+  
+  it_should_behave_like 'non-reifiable constraint'
+  it_should_behave_like 'non-negatable constraint'
+end
+

data/specs/constraints/int_enum/count.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/../property_helper'
+
+class CountSampleProblem < Gecode::Model
+  attr :list
+  attr :element
+  attr :target
+  
+  def initialize
+    @list = int_var_array(4, 0..3)
+    @element = int_var(0..3)
+    @target = int_var(0..4)
+    branch_on @list
+    branch_on @element
+  end
+end
+
+describe Gecode::IntEnum::Count, ' (with int var)' do
+  before do
+    @model = CountSampleProblem.new
+    @list = @model.list
+    @element = @model.element
+    @target = @model.target
+    
+    # For int operand producing property spec.
+    @property_types = [:int_enum, :int]
+    @select_property = lambda do |int_enum, int|
+      int_enum.count(int)
+    end
+    @selected_property = @list.count(@element)
+    @constraint_class = 
+      Gecode::IntEnum::Count::CountConstraint
+  end
+
+  it 'should constrain the count' do
+    @list.count(@element).must == 2
+    @model.solve!
+    @list.values.map{ |x| x == @element.value }.inject(0) do |sum, b| 
+      sum += b ? 1 : 0
+    end.should == 2
+  end
+  
+  it_should_behave_like(
+    'property that produces int operand by short circuiting relations')
+end
+
+describe Gecode::IntEnum::Count, ' (with fixnum)' do
+  before do
+    @model = CountSampleProblem.new
+    @list = @model.list
+    @target = @model.target
+    
+    # For int operand producing property spec.
+    @property_types = [:int_enum]
+    @select_property = lambda do |int_enum|
+      int_enum.count(1)
+    end
+    @selected_property = @list.count(1)
+    @constraint_class = 
+      Gecode::IntEnum::Count::CountConstraint
+  end
+
+  it 'should constrain the count' do
+    @list.count(1).must == 2
+    @model.solve!
+    @list.values.map{ |x| x == 1 }.inject(0) do |sum, b| 
+      sum += b ? 1 : 0
+    end.should == 2
+  end
+  
+  it_should_behave_like(
+    'property that produces int operand by short circuiting relations')
+end

data/specs/constraints/int_enum/distinct.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+class DistinctSampleProblem < Gecode::Model
+  def initialize
+    vars_is_an int_var_array(2, 0..1)
+    branch_on vars
+  end
+end
+
+describe Gecode::IntEnum::Distinct do
+  before do
+    @model = DistinctSampleProblem.new
+
+    @types = [:int_enum]
+    @invoke = lambda do |receiver, hash| 
+      receiver.distinct(hash)
+      @model.solve!
+    end
+    @expect = lambda do |var, opts, reif_var|
+      Gecode::Raw.should_receive(:distinct).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        var, *opts)
+    end
+  end
+
+  it 'should constrain variables to be distinct' do
+    @model.vars.must_be.distinct
+    @model.solve!
+    @model.vars[0].value.should_not == @model.vars[1].value
+  end
+
+  it_should_behave_like 'non-reifiable constraint'
+  it_should_behave_like 'non-negatable constraint'
+end
+
+describe Gecode::IntEnum::Distinct, ' (with offsets)' do
+  before do
+    @model = DistinctSampleProblem.new
+
+    @types = [:int_enum]
+    @invoke = lambda do |receiver, hash| 
+      receiver.distinct hash.update(:offsets => [1,2])
+      @model.solve!
+    end
+    @expect = lambda do |var, opts, reif_var|
+      if reif_var.nil?
+        Gecode::Raw.should_receive(:distinct).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          [1,2], var, *opts)
+      else
+        Gecode::Raw.should_receive(:distinct).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          [1,2], var, reif_var, *opts)
+      end
+    end
+  end
+
+  it 'should constrain variables to be distinct' do
+    @model.vars.must_be.distinct(:offsets => [-1, 0])
+    x, y = @model.solve!.vars
+    (x.value - 1).should_not == y.value
+  end
+  
+  # This tests two distinct in conjunction. It's here because of a bug found.
+  it 'should play nice with normal distinct' do
+    @model.vars.must_be.distinct(:offsets => [-1, 0])
+    @model.vars.must_be.distinct(:offsets => [0, -1])
+    @model.vars.must_be.distinct
+    lambda{ @model.solve! }.should raise_error(Gecode::NoSolutionError)
+  end
+
+  it 'should raise error if the offsets are of an incorrect type' do
+    lambda do
+      @model.vars.must_be.distinct(:offsets => :foo)
+    end.should raise_error(TypeError)
+  end
+  
+  it_should_behave_like 'non-reifiable constraint'
+  it_should_behave_like 'non-negatable constraint'
+end

data/specs/constraints/int_enum/element.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/../property_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 @store
+  end
+end
+
+describe Gecode::IntEnum::Element do
+  before do
+    @model = ElementSampleProblem.new
+    @prices = @model.prices
+    @target = @price = @model.price
+    @store = @model.store
+    
+    # For int operand producing property spec.
+    @property_types = [:int_enum, :int]
+    @select_property = lambda do |int_enum, int|
+      int_enum[int]
+    end
+    @selected_property = @prices[@store]
+    @constraint_class = Gecode::BlockConstraint
+  end
+
+  it 'should not disturb normal array access' do
+    @prices[2].should_not be_nil
+  end
+
+  it 'should constrain the selected element' do
+    @prices[@store].must == 63
+    @prices.values_at(0,2,3).each{ |x| x.must < 50 }
+    @model.solve!.should_not be_nil
+    @store.value.should equal(1)
+  end
+
+  it 'should be translated into an element constraint' do
+    @prices[@store].must == @price
+    @model.allow_space_access do
+      Gecode::Raw.should_receive(:element).once.with( 
+        an_instance_of(Gecode::Raw::Space), 
+        an_instance_of(Gecode::Raw::IntVarArray), 
+        @store.bind, @price.bind, 
+        Gecode::Raw::ICL_DEF,
+        Gecode::Raw::PK_DEF)
+    end
+    @model.solve!
+  end
+  
+  it_should_behave_like(
+    'property that produces int operand by short circuiting equality')
+end

data/specs/constraints/int_enum/equality.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+describe Gecode::IntEnum::Equality do
+  before do
+    @model = Gecode::Model.new
+    @vars = @model.int_var_array(4, -2..2)
+
+    @types = [:int_enum]
+    @invoke = lambda do |receiver, hash| 
+      receiver.equal(hash)
+      @model.solve!
+    end
+    @expect = lambda do |var, opts, reif_var|
+      Gecode::Raw.should_receive(:rel).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        var, Gecode::Raw::IRT_EQ, *opts)
+    end
+  end
+  
+  it 'should constrain elements to be equal' do
+    @vars[1].must == 1
+    @vars.must_be.equal
+    @model.solve!
+    @vars.values.each{ |x| x.should == 1 }
+  end
+  
+  it_should_behave_like 'non-reifiable constraint'
+  it_should_behave_like 'non-negatable constraint'
+end

data/specs/constraints/int_enum/extensional.rb

@@ -0,0 +1,224 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+# Assumes that @variables, @expected_array and @tuples are defined.
+describe 'int tuple constraint', :shared => true do
+  it 'should not allow negation' do
+    lambda do 
+      @variables.must_not_be.in @tuples
+    end.should raise_error(Gecode::MissingConstraintError)
+  end
+  
+  it 'should not allow empty tuples' do
+    lambda do 
+      @variables.must_be.in []
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should not allow tuples of sizes other than the number of variables' do
+    lambda do 
+      @variables.must_be.in([@tuples.first * 2])
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should raise error if the right hand side does not contain tuples of correct type' do
+    lambda do 
+      size = @variables.size
+      @variables.must_be.in ['h'*size, 'i'*size] 
+    end.should raise_error(TypeError)
+  end
+end
+
+describe Gecode::IntEnum::Extensional, ' (tuple constraint)' do
+  before do
+    @model = Gecode::Model.new
+    @tuples = [[1,7], [5,1]]
+    @variables = @digits = @model.int_var_array(2, 0..9)
+    @model.branch_on @digits
+
+    @types = [:int_enum]
+    @invoke = lambda do |receiver, hash| 
+      receiver.in([[1, 7, 5, 3, 0], [8, 9, 9, 9, 0]], hash)
+      @model.solve!
+    end
+    @expect = lambda do |var, opts, reif_var|
+      Gecode::Raw.should_receive(:extensional).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        var, an_instance_of(Gecode::Raw::TupleSet), *opts)
+    end
+  end
+  
+  it 'should constrain the domain of all variables' do
+    @digits.must_be.in @tuples
+    
+    found_solutions = []
+    @model.each_solution do |m|
+      found_solutions << @digits.values
+    end
+    
+    found_solutions.size.should == 2
+    (found_solutions - @tuples).should be_empty
+  end
+  
+  it 'should raise error if the right hand side is not an enumeration' do
+    lambda{ @digits.must_be.in 4711 }.should raise_error(TypeError)
+  end
+  
+  it 'should raise error if the right hand side does not contain tuples' do
+    lambda{ @digits.must_be.in [17, 4711] }.should raise_error(TypeError)
+  end
+  
+  it_should_behave_like 'int tuple constraint'
+  it_should_behave_like 'non-reifiable constraint'
+end
+
+# Assumes that @variables, @expected_array, @value1, @value2 (must not
+# equal @value1) and @regexp are defined. 
+describe 'int regular expression constraint', :shared => true do
+  it 'should handle values grouped in a single array' do
+    @variables.must.match [@value1, @value2, @value1]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value1, @value2, @value1]
+  end
+
+  it 'should allow nested groups of values' do
+    @variables.must.match [@value1, [@value2, [@value1]]]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value1, @value2, @value1]
+  end
+  
+  it 'should handle the repeat operation' do
+    @variables.must.match [@value1, @model.repeat([@value2], 1, 2)]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value1, @value2, @value2]
+  end
+
+  it 'should handle repeat operations that do not encase constant values in arrays' do
+    @variables.must.match [@value1, @model.repeat(@value2, 1, 2)]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value1, @value2, @value2]
+  end
+
+  it 'should handle nested repeat operations' do
+    @variables.must.match [[@model.repeat(@model.repeat([@value2], 1, 3), 1, 2)]]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value2, @value2, @value2]
+  end
+
+  it 'should handle nested repeat operations (2)' do
+    @variables.must.match [[@model.repeat([@model.repeat(@value2, 1, 3)], 1, 2)]]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value2, @value2, @value2]
+  end
+
+  it 'should interpret the repeat operation with the last argument omitted as only giving a lower bound' do
+    @variables.must.match [@value1, @model.repeat([@value2], 1)]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value1, @value2, @value2]
+  end
+
+  it 'should interpret the repeat operation with all but the first argument omitted as not giving any bound' do
+    @variables.must.match [@model.repeat(@value2), @value1, @value1, @value1]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value1, @value1, @value1]
+  end
+
+  it 'should interpret the repeat operation with all but the first argument omitted as not giving any bound (2)' do
+    @variables.must.match [@model.repeat(@value2)]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value2, @value2, @value2]
+  end
+
+  it 'should translate at_most_once(reg) to repeat(reg, 0, 1)' do
+    @model.should_receive(:repeat).once.with([@value1], 0, 1)
+    @model.at_most_once [@value1]
+  end
+
+  it 'should translate at_least_once(reg) to repeat(reg, 1)' do
+    @model.should_receive(:repeat).once.with([@value1], 1)
+    @model.at_least_once [@value1]
+  end
+
+  it 'should raise error if the right hand side is not an enumeration' do
+    lambda do 
+      @variables.must.match Object.new
+    end.should raise_error(TypeError)
+  end
+  
+  it 'should raise error if the right hand side does not a regexp of the right type' do
+    lambda do 
+      @variables.must.match [@value1, 'foo'] 
+    end.should raise_error(TypeError)
+  end
+
+  it 'should raise error if the right hand side contains a nested element of an incorrect type' do
+    lambda do 
+      @variables.must.match [@value1, [@value2, 'foo']] 
+    end.should raise_error(TypeError)
+  end
+
+  it 'should raise error if the repeat operation is given arguments of incorrect type (2)' do
+    lambda do 
+      @variables.must.match @model.repeat(@value1, [0], 1)
+    end.should raise_error(TypeError)
+  end
+
+  it 'should raise error if the repeat operation is given arguments of incorrect type (3)' do
+    lambda do 
+      @variables.must.match @model.repeat(@value1, 0, [1])
+    end.should raise_error(TypeError)
+  end
+  
+  it 'should raise error if the repeat operation is given arguments of incorrect type' do
+    lambda do 
+      @variables.must.match @model.repeat('foo', 0, 1)
+    end.should raise_error(TypeError)
+  end
+
+  it 'should not allow negation' do
+    lambda do 
+      @variables.must_not.match @regexp
+    end.should raise_error(Gecode::MissingConstraintError)
+  end
+end
+
+describe Gecode::IntEnum::Extensional, ' (regexp constraint)' do
+  before do
+    @model = Gecode::Model.new
+    @variables = @digits = @model.int_var_array(3, 0..9)
+    @model.branch_on @digits
+    @expected_array = an_instance_of Gecode::Raw::IntVarArray
+    @value1 = 3
+    @value2 = 5
+    @regexp = [1, @model.any(3, 4), @model.at_most_once(5)]
+
+    @types = [:int_enum]
+    @invoke = lambda do |receiver, hash| 
+      receiver.match(@regexp, hash)
+      @model.solve!
+    end
+    @expect = lambda do |var, opts, reif_var|
+      Gecode::Raw.should_receive(:extensional).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        var, an_instance_of(Gecode::Raw::REG), *opts)
+    end
+  end
+
+  it 'should handle the any operation' do
+    @digits.must.match [1, @model.any(1, 2, 3), 3]
+    @model.solve!.should_not be_nil
+    values = @digits.values
+    values.size.should == 3 
+    values.should == values.sort
+  end
+
+  it 'should handle the any operator with nested expressions' do
+    @digits.must.match [1, @model.any(@model.at_least_once(2), [3, 5])]
+    @digits[2].must < 4
+    @model.solve!.should_not be_nil
+    @digits.values.should == [1,2,2]
+  end
+
+  it_should_behave_like 'int regular expression constraint'
+  it_should_behave_like 'non-reifiable constraint'
+end
+