gecoder-with-gecode 0.8.3 → 0.9.0

data/specs/constraints/bool/linear.rb

@@ -0,0 +1,213 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+class BoolLinearSampleProblem < Gecode::Model
+  attr :x
+  attr :y
+  attr :z
+  
+  def initialize
+    @x = self.bool_var
+    @y = self.bool_var
+    @z = self.bool_var
+    branch_on wrap_enum([@x, @y, @z])
+  end
+end
+
+class TrueClass
+  def to_i
+    1
+  end
+end
+
+class FalseClass
+  def to_i
+    0
+  end
+end
+
+describe Gecode::Int::Linear, '(with booleans)' do
+  before do
+    @model = BoolLinearSampleProblem.new
+    @x = @model.x
+    @y = @model.y
+    @z = @model.z
+    @operand = @x + @y
+  end
+
+  it 'should handle addition with a variable' do
+    (@x + @y).must == 0
+    sol = @model.solve!
+    x = sol.x.value.to_i
+    y = sol.y.value.to_i
+    (x + y).should be_zero
+  end
+  
+  it 'should handle reification (1)' do
+    bool = @model.bool_var
+    (@x + @y).must.equal(0, :reify => bool)
+    bool.must_be.false
+    sol = @model.solve!
+    x = sol.x.value.to_i
+    y = sol.y.value.to_i
+    (x + y).should_not be_zero
+  end
+
+  it 'should handle reification (2)' do
+    bool = @model.bool_var
+    (@x + @y).must.equal(0, :reify => bool)
+    bool.must_be.true
+    sol = @model.solve!
+    x = sol.x.value.to_i
+    y = sol.y.value.to_i
+    (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.value.to_i
+    y = sol.y.value.to_i
+    z = sol.z.value.to_i
+    (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.value.to_i
+    y = sol.y.value.to_i
+    (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.value.to_i
+    y = sol.y.value.to_i
+    (x + y).should equal(1)
+  end
+  
+  it 'should handle single booleans as left hand side' do
+    @x.must == @y + 1 
+    sol = @model.solve!
+    x = sol.x.value.to_i
+    y = sol.y.value.to_i
+    x.should equal(y + 1)
+  end
+
+  it 'should handle single booleans as left hand side (2)' do
+    @x.must == @y + @z 
+    sol = @model.solve!
+    x = sol.x.value.to_i
+    y = sol.y.value.to_i
+    z = sol.z.value.to_i
+    x.should equal(y + z)
+  end
+
+  it 'should handle single booleans as left hand side (3)' do
+    bool = @model.bool_var
+    @x.must.equal(@y + @z, :reify => bool)
+    bool.must_be.false
+    sol = @model.solve!
+    x = sol.x.value.to_i
+    y = sol.y.value.to_i
+    z = sol.z.value.to_i
+    x.should_not equal(y + z)
+  end
+
+  it 'should handle variables as right hand side' do
+    (@x + @y).must == @z
+    sol = @model.solve!
+    x = sol.x.value.to_i
+    y = sol.y.value.to_i
+    z = sol.z.value.to_i
+    (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.value.to_i
+    y = sol.y.value.to_i
+    z = sol.z.value.to_i
+    (x + y).should equal(z + y)
+  end
+  
+  it 'should raise error on invalid right hand sides' do
+    lambda do 
+      (@x + @y).must == 'z'
+    end.should raise_error(TypeError) 
+  end
+
+  it 'should raise error if a fixnum is not used in multiplication' do
+    lambda do
+      (@x * @y).must == 0
+    end.should raise_error(TypeError) 
+  end
+
+  it 'should raise error if bools are combined with integer variables' do
+    lambda do
+      (@x + @model.int_var).must == 0
+    end.should raise_error(TypeError)
+  end
+  
+  it 'should handle coefficients other than 1' do
+    (@x * 2 + @y).must == 0
+    sol = @model.solve!
+    x = sol.x.value.to_i
+    y = sol.y.value.to_i
+    (2*x + y).should equal(0)
+  end
+  
+  it 'should handle addition with constants' do
+    (@y + 1).must == 1
+    sol = @model.solve!
+    y = sol.y.value.to_i
+    (y + 1).should equal(1)
+  end
+  
+  it 'should handle subtraction with a constant' do
+    (@x - 1).must == 0
+    sol = @model.solve!
+    x = sol.x.value.to_i
+    (x - 1).should be_zero
+  end
+
+  it 'should handle parenthesis' do
+    (@x - (@y + @z)).must == 1
+    sol = @model.solve!
+    x = sol.x.value.to_i
+    y = sol.y.value.to_i
+    z = sol.z.value.to_i
+    (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.value.to_i
+    y = sol.y.value.to_i
+    z = sol.z.value.to_i
+    (((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.value.to_i + sol.y.value.to_i).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.value.to_i + sol.y.value.to_i).should_not.send(relation, 1)
+    end
+  end
+end

data/specs/constraints/bool_enum/bool_enum_relation.rb

@@ -0,0 +1,117 @@
+require File.dirname(__FILE__) + '/../property_helper'
+
+class BoolEnumSampleProblem < Gecode::Model
+  attr :bools
+  attr :b1
+  attr :b2
+  
+  def initialize
+    @bools = bool_var_array(4)
+    @b1 = bool_var
+    @b2 = bool_var
+    branch_on @bools
+    branch_on wrap_enum([@b1, @b2])
+  end
+end
+
+# Expects @stub, which contains the started constraint and @compute_result 
+# which computes whether the left hand side is true or not.
+describe 'bool enum relation constraint', :shared => true do
+  it 'should handle being constrained to be true' do
+    @stub.must_be.true
+    @model.solve!
+    @compute_result.call.should be_true
+  end
+  
+  it 'should handle being constrained to be negated true' do
+    @stub.must_not_be.true
+    @model.solve!
+    @compute_result.call.should_not be_true
+  end
+  
+  it 'should handle being constrained to be false' do
+    @stub.must_be.false
+    @model.solve!
+    @compute_result.call.should_not be_true
+  end
+  
+  it 'should handle being constrained to be negated false' do
+    @stub.must_not_be.false
+    @model.solve!
+    @compute_result.call.should be_true
+  end
+  
+  it 'should handle being constrained to be equal to a variable' do
+    @stub.must_be == @b1
+    @model.solve!
+    @compute_result.call.should == @b1.value
+  end
+  
+  it 'should handle being constrained to not be equal to a variable' do
+    @stub.must_not_be == @b1
+    @model.solve!
+    @compute_result.call.should_not == @b1.value
+  end
+  
+  it 'should handle being constrained to be equal to be a nested expression' do
+    @stub.must_be == (@b1 | @b2) & @b1
+    @model.solve!
+    @compute_result.call.should == (@b1.value | @b2.value) & @b1.value
+  end
+  
+  it 'should handle being constrained to not be equal to be a nested expression' do
+    @stub.must_not_be == (@b1 | @b2) & @b1
+    @model.solve!
+    @compute_result.call.should_not == (@b1.value | @b2.value) & @b1.value
+  end
+end
+
+describe Gecode::BoolEnum::Relation, ' (conjunction)' do
+  before do
+    @model = BoolEnumSampleProblem.new
+    @bools = @model.bools
+    @b1 = @model.b1
+    @b2 = @model.b2
+    
+    # For property spec.
+    @property_types = [:bool_enum]
+    @select_property = lambda do |bool_enum|
+      bool_enum.conjunction
+    end
+    @selected_property = @bools.conjunction
+    @constraint_class = Gecode::BlockConstraint
+    
+    # For bool enum spec.
+    @stub = @selected_property
+    @compute_result = lambda{ @bools.all?{ |b| b.value } }
+  end
+  
+  it_should_behave_like 'bool enum relation constraint'
+  it_should_behave_like(
+    'property that produces bool operand by short circuiting equality')
+end
+
+describe Gecode::BoolEnum::Relation, ' (disjunction)' do
+  before do
+    @model = BoolEnumSampleProblem.new
+    @bools = @model.bools
+    @b1 = @model.b1
+    @b2 = @model.b2
+    
+    # For constraint option spec.
+    @property_types = [:bool_enum]
+    @select_property = lambda do |bool_enum|
+      bool_enum.disjunction
+    end
+    @selected_property = @bools.disjunction
+    @constraint_class = Gecode::BlockConstraint
+    
+    # For bool enum spec.
+    @stub = @selected_property
+    @compute_result = lambda{ @bools.any?{ |b| b.value } }
+  end
+  
+  it_should_behave_like 'bool enum relation constraint'
+  it_should_behave_like(
+    'property that produces bool operand by short circuiting equality')
+end

data/specs/constraints/bool_enum/channel.rb

@@ -0,0 +1,102 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+class BoolChannelSampleProblem < Gecode::Model
+  attr :bool_enum
+  attr :bool
+  attr :int
+  
+  def initialize
+    @bool_enum = bool_var_array(4)
+    @int = int_var(0..3)
+    @bool = bool_var
+    
+    branch_on @int
+  end
+end
+
+describe Gecode::BoolEnum::Channel, ' (bool enum as lhs with int variable)' do
+  before do
+    @model = BoolChannelSampleProblem.new
+    @bools = @model.bool_enum
+    @int = @model.int
+
+    @types = [:bool_enum, :int]
+    @invoke = lambda do |receiver, int, hash| 
+      receiver.channel(int, 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, 0, *opts)
+    end
+  end
+
+  it 'should channel the bool enum with the integer variable' do
+    @int.must > 2
+    @bools.must.channel @int
+    @model.solve!.should_not be_nil
+    int_val = @int.value
+    @bools.values.each_with_index do |bool, index|
+      bool.should == (index == int_val)
+    end
+  end
+  
+  it 'should take the offset into account when channeling' do
+    @int.must > 2
+    offset = 1
+    @bools.must.channel(@int, :offset => offset)
+    @model.solve!.should_not be_nil
+    int_val = @int.value
+    @bools.values.each_with_index do |bool, index|
+      bool.should == (index + offset == int_val)
+    end
+  end
+
+  it_should_behave_like 'non-reifiable constraint'
+  it_should_behave_like 'non-negatable constraint'
+end
+
+
+describe Gecode::BoolEnum::Channel, ' (int variable as lhs with bool enum)' do
+  before do
+    @model = BoolChannelSampleProblem.new
+    @bools = @model.bool_enum
+    @int = @model.int
+
+    @types = [:int, :bool_enum]
+    @invoke = lambda do |receiver, bool_enum, hash| 
+      receiver.channel(bool_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), 
+        var2, var1, 0, *opts)
+    end
+  end
+
+  it 'should channel the bool enum with the integer variable' do
+    @int.must > 2
+    @int.must.channel @bools
+    @model.solve!.should_not be_nil
+    int_val = @int.value
+    @bools.values.each_with_index do |bool, index|
+      bool.should == (index == int_val)
+    end
+  end
+  
+  it 'should take the offset into account when channeling' do
+    @int.must > 2
+    offset = 1
+    @int.must.channel(@bools, :offset => offset)
+    @model.solve!.should_not be_nil
+    int_val = @int.value
+    @bools.values.each_with_index do |bool, index|
+      bool.should == (index + offset == int_val)
+    end
+  end
+  
+  it_should_behave_like 'non-reifiable constraint'
+  it_should_behave_like 'non-negatable constraint'
+end

data/specs/constraints/{extensional.rb → bool_enum/extensional.rb}

@@ -1,21 +1,7 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/constraint_helper'
+require File.dirname(__FILE__) + '/../constraint_helper'
 
 # Assumes that @variables, @expected_array and @tuples are defined.
-describe 'tuple constraint', :shared => true do
-  before do
-    @invoke_options = lambda do |hash| 
-      @variables.must_be.in(@tuples, hash) 
-      @model.solve!
-    end
-    @expect_options = option_expectation do |strength, kind, reif_var|
-      Gecode::Raw.should_receive(:extensional).once.with(
-        an_instance_of(Gecode::Raw::Space), 
-        @expected_array, 
-        an_instance_of(Gecode::Raw::TupleSet), strength, kind)
-    end
-  end
-  
+describe 'bool tuple constraint', :shared => true do
   it 'should not allow negation' do
     lambda do 
       @variables.must_not_be.in @tuples
@@ -40,51 +26,26 @@ describe 'tuple constraint', :shared => true do
       @variables.must_be.in ['h'*size, 'i'*size] 
     end.should raise_error(TypeError)
   end
-  
-  it_should_behave_like 'non-reifiable constraint'
-end
-
-describe Gecode::Constraints::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
-    
-    @expected_array = an_instance_of Gecode::Raw::IntVarArray
-  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 'tuple constraint'
 end
 
-describe Gecode::Constraints::BoolEnum::Extensional, ' (tuple constraint)' do
+describe Gecode::BoolEnum::Extensional, ' (tuple constraint)' do
   before do
     @model = Gecode::Model.new
     @tuples = [[true, false, true], [false, false, true]]
     @variables = @bools = @model.bool_var_array(3)
     @model.branch_on @bools
     
-    @expected_array = an_instance_of Gecode::Raw::BoolVarArray
+    @types = [:bool_enum]
+    @invoke = lambda do |receiver, hash| 
+      receiver.in([[true, false, true, false, true], 
+                  [false, true, true, true, true]], 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
@@ -107,25 +68,14 @@ describe Gecode::Constraints::BoolEnum::Extensional, ' (tuple constraint)' do
     lambda{ @bools.must_be.in [true, false] }.should raise_error(TypeError)
   end
   
-  it_should_behave_like 'tuple constraint'
+  it_should_behave_like 'bool 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 'regular expression constraint', :shared => true do
-  before do
-    @invoke_options = lambda do |hash| 
-      @variables.must.match(@regexp, hash)
-      @model.solve!
-    end
-    @expect_options = option_expectation do |strength, kind, reif_var|
-      Gecode::Raw.should_receive(:extensional).once.with(
-        an_instance_of(Gecode::Raw::Space), 
-        @expected_array, 
-        an_instance_of(Gecode::Raw::REG), strength, kind)
-    end
-  end
-
+describe 'bool 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
@@ -231,40 +181,9 @@ describe 'regular expression constraint', :shared => true do
       @variables.must_not.match @regexp
     end.should raise_error(Gecode::MissingConstraintError)
   end
-
-  it_should_behave_like 'non-reifiable constraint'
-end
-
-describe Gecode::Constraints::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)]
-  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 'regular expression constraint'
 end
 
-describe Gecode::Constraints::BoolEnum::Extensional, ' (regexp constraint)' do
+describe Gecode::BoolEnum::Extensional, ' (regexp constraint)' do
   before do
     @model = Gecode::Model.new
     @variables = @bools = @model.bool_var_array(3)
@@ -273,6 +192,17 @@ describe Gecode::Constraints::BoolEnum::Extensional, ' (regexp constraint)' do
     @value1 = true
     @value2 = false
     @regexp = [true, @model.any(true, false), @model.at_most_once(true)]
+
+    @types = [:bool_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
@@ -290,5 +220,6 @@ describe Gecode::Constraints::BoolEnum::Extensional, ' (regexp constraint)' do
     @bools.values.should == [true, true, true]
   end
 
-  it_should_behave_like 'regular expression constraint'
+  it_should_behave_like 'bool regular expression constraint'
+  it_should_behave_like 'non-reifiable constraint'
 end