gecoder 0.8.1 → 0.8.2

data/specs/constraints/arithmetic.rb

@@ -17,6 +17,55 @@ class ArithmeticSampleProblem < Gecode::Model
   end
 end
 
+# Construct a method placing expectations for an arithmetic constraint with the 
+# specified arity (number of variables before must) and the specified name in 
+# Gecode.   
+def arithmetic_expectation(gecode_name, arity)
+  lambda do |relation, rhs, strength, kind, reif_var, negated|
+    # Construct the arguments expected to be passed to the Gecode variant of 
+    # the constraint.
+    rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
+    expected_gecode_arguments = [an_instance_of(Gecode::Raw::Space)]
+    arity.times do
+      expected_gecode_arguments << an_instance_of(Gecode::Raw::IntVar)
+    end
+    can_use_single_gecode_constraint = reif_var.nil? && !negated && 
+      relation == Gecode::Raw::IRT_EQ && !rhs.kind_of?(Fixnum)
+    if can_use_single_gecode_constraint
+      expected_gecode_arguments << rhs
+    else
+      expected_gecode_arguments << an_instance_of(Gecode::Raw::IntVar)
+    end
+    expected_gecode_arguments.concat([strength, kind])
+    
+    # Create the actual method producing the expectation.
+    @model.allow_space_access do
+      if reif_var.nil?
+        if can_use_single_gecode_constraint
+          Gecode::Raw.should_receive(gecode_name).once.with(
+            *expected_gecode_arguments)
+          Gecode::Raw.should_receive(:rel).exactly(0).times
+        else
+          Gecode::Raw.should_receive(gecode_name).once.with(
+            *expected_gecode_arguments)
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::IntVar), 
+            relation, rhs, strength, kind)
+        end
+      else
+        Gecode::Raw.should_receive(gecode_name).once.with(
+          *expected_gecode_arguments)
+        Gecode::Raw.should_receive(:rel).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
+          an_instance_of(Gecode::Raw::BoolVar),
+          strength, kind)
+      end
+    end
+  end
+end
+
 # Requires @stub, @target, @model and @expect.
 describe 'arithmetic constraint', :shared => true do
   before do
@@ -228,46 +277,7 @@ describe Gecode::Constraints::Int::Arithmetic, ' (multiplication)' do
     @stub = @var * @var2
     @target = @model.var3
     
-    # Creates an expectation corresponding to the specified input.
-    @expect = lambda do |relation, rhs, strength, kind, reif_var, negated|
-      @model.allow_space_access do
-        rhs = an_instance_of(Gecode::Raw::IntVar) if rhs.respond_to? :bind
-        if reif_var.nil?
-          if !negated and relation == Gecode::Raw::IRT_EQ and 
-              !rhs.kind_of? Fixnum
-            Gecode::Raw.should_receive(:mult).once.with(
-              an_instance_of(Gecode::Raw::Space),
-              an_instance_of(Gecode::Raw::IntVar), 
-              an_instance_of(Gecode::Raw::IntVar), 
-              rhs, strength, kind)
-            Gecode::Raw.should_receive(:rel).exactly(0).times
-          else
-            Gecode::Raw.should_receive(:mult).once.with(
-              an_instance_of(Gecode::Raw::Space),
-              an_instance_of(Gecode::Raw::IntVar), 
-              an_instance_of(Gecode::Raw::IntVar), 
-              an_instance_of(Gecode::Raw::IntVar), 
-              strength, kind)
-            Gecode::Raw.should_receive(:rel).once.with(
-              an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVar), 
-              relation, rhs, strength, kind)
-          end
-        else
-          Gecode::Raw.should_receive(:mult).once.with(
-            an_instance_of(Gecode::Raw::Space),
-            an_instance_of(Gecode::Raw::IntVar), 
-            an_instance_of(Gecode::Raw::IntVar), 
-            an_instance_of(Gecode::Raw::IntVar), 
-            strength, kind)
-          Gecode::Raw.should_receive(:rel).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVar), relation, rhs, 
-            an_instance_of(Gecode::Raw::BoolVar),
-            strength, kind)
-        end
-      end
-    end
+    @expect = arithmetic_expectation(:mult, 2)
   end
   
   it 'should constrain the value of the multiplication' do
@@ -281,4 +291,61 @@ describe Gecode::Constraints::Int::Arithmetic, ' (multiplication)' do
   end
   
   it_should_behave_like 'arithmetic constraint'
-end
+end
+
+describe Gecode::Constraints::Int::Arithmetic, ' (squared)' do
+  before do
+    @model = ArithmeticSampleProblem.new
+    @var = @model.var
+    @stub = @var.squared
+    @target = @model.var2
+    
+    @expect = arithmetic_expectation(:sqr, 1)
+  end
+  
+  it 'should constrain the value of the variable squared' do
+    @var.squared.must == 9
+    sol = @model.solve!
+    sol.var.value.abs.should == 3
+  end
+  
+  it_should_behave_like 'arithmetic constraint'
+end
+
+describe Gecode::Constraints::Int::Arithmetic, ' (square root)' do
+  before do
+    @model = ArithmeticSampleProblem.new
+    @var = @model.var
+    @stub = @var.square_root
+    @target = @model.var2
+    
+    @expect = arithmetic_expectation(:sqrt, 1)
+  end
+  
+  it 'should constrain the square root of the variable' do
+    @var.square_root.must == 3
+    sol = @model.solve!
+    Math.sqrt(sol.var.value).floor.should == 3
+  end
+  
+  it 'should constrain the square root of the variable (2)' do
+    @var.square_root.must == 0
+    sol = @model.solve!
+    Math.sqrt(sol.var.value).floor.should == 0
+  end
+  
+  it 'should constrain the square root of the variable (3)' do
+    @var.must < 0
+    @var.square_root.must == 0
+    @model.solve!.should be_nil
+  end
+  
+  it 'should round down the square root' do
+    @var.must > 4
+    @var.square_root.must == 2
+    sol = @model.solve!
+    sol.var.value.should be_between(5,8)
+  end
+  
+  it_should_behave_like 'arithmetic constraint'
+end

data/specs/constraints/boolean.rb

@@ -228,5 +228,9 @@ describe Gecode::Constraints::Bool do
     sol.b3.value.should be_true
   end
   
+  it 'should raise error on right hand sides of the wrong type' do
+    lambda{ @b1.must == 'hello' }.should raise_error(TypeError) 
+  end
+  
   it_should_behave_like 'reifiable constraint'
 end

data/specs/constraints/channel.rb

@@ -16,6 +16,20 @@ class ChannelSampleProblem < Gecode::Model
   end
 end
 
+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 wrap_enum([@int])
+  end
+end
+
 describe Gecode::Constraints::IntEnum::Channel, ' (two int enums)' do
   before do
     @model = ChannelSampleProblem.new
@@ -67,13 +81,21 @@ describe Gecode::Constraints::IntEnum::Channel, ' (one int enum and one set enum
     @model = ChannelSampleProblem.new
     @positions = @model.positions
     @sets = @model.sets
+    
+    @invoke_options = lambda do |hash| 
+      @positions.must.channel @sets, hash
+      @model.solve!
+    end
+    @expect_options = option_expectation do |strength, kind, reif_var|
+      Gecode::Raw.should_receive(:channel).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        an_instance_of(Gecode::Raw::IntVarArray), 
+        an_instance_of(Gecode::Raw::SetVarArray))
+    end
   end
 
   it 'should translate into a channel constraint' do
-    Gecode::Raw.should_receive(:channel).once.with(
-      an_instance_of(Gecode::Raw::Space), 
-        an_instance_of(Gecode::Raw::IntVarArray), 
-        an_instance_of(Gecode::Raw::SetVarArray))
+    @expect_options.call({})
     @positions.must.channel @sets
     @model.solve!
   end
@@ -87,6 +109,8 @@ describe Gecode::Constraints::IntEnum::Channel, ' (one int enum and one set enum
       sets[position].value.should include(i)
     end
   end
+  
+  it_should_behave_like 'non-reifiable set constraint'
 end
 
 describe Gecode::Constraints::SetEnum, ' (channel with set as left hand side)' do
@@ -123,4 +147,210 @@ describe Gecode::Constraints::SetEnum, ' (channel with set as left hand side)' d
   end
   
   it_should_behave_like 'non-reifiable set constraint'
-end
+end
+
+# Requires @model, @bool and @int. Also requires @place_constraint which is a 
+# method that takes five variables: a boolean variable, an integer variable, 
+# the name of the equality method to use, whether or not the constraint should 
+# be negated and a hash of options, and places the channel constraint on them.
+describe 'channel constraint between one int and one bool variable', :shared => true do 
+  before do
+    @invoke_options = lambda do |hash| 
+      @place_constraint.call(@bool, @int, :==, false, hash)
+      @model.solve!
+    end
+    @expect_options = option_expectation do |strength, kind, reif_var|
+      Gecode::Raw.should_receive(:channel).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        an_instance_of(Gecode::Raw::IntVar), 
+        an_instance_of(Gecode::Raw::BoolVar), 
+        strength, kind)
+    end
+  end
+  
+  ([:==] + Gecode::Constraints::Util::COMPARISON_ALIASES[:==]).each do |ali|
+    it "should translate #{ali} into a channel constraint" do
+      @expect_options.call({})
+      @place_constraint.call(@bool, @int, ali, false, {})
+      @model.solve!
+    end
+  end
+  
+  it 'should constrain the int variable to be 1 when the boolean variable is true' do
+    @bool.must_be.true
+    @place_constraint.call(@bool, @int, :==, false, {})
+    @model.solve!
+    @int.value.should == 1
+  end
+  
+  it 'should constrain the int variable to be 0 when the boolean variable is false' do
+    @bool.must_be.false
+    @place_constraint.call(@bool, @int, :==, false, {})
+    @model.solve!
+    @int.value.should == 0
+  end
+  
+  it 'should not allow negation' do
+    lambda do
+      @place_constraint.call(@bool, @int, :==, true, {})
+    end.should raise_error(Gecode::MissingConstraintError) 
+  end
+  
+  it_should_behave_like 'non-reifiable constraint'
+end
+
+describe Gecode::Constraints::Int::Channel, ' (one int and one bool variable)' do
+  before do
+    @model = BoolChannelSampleProblem.new
+    @bool = @model.bool_var
+    @int = @model.int_var
+
+    @place_constraint = lambda do |bool, int, equals_method_name, negate, options|
+      if negate
+        int.must_not.method(equals_method_name).call(bool, options)
+      else
+        int.must.method(equals_method_name).call(bool, options)
+      end
+    end
+  end
+
+  it 'should not shadow linear boolean constraints' do
+    lambda do
+      (@bool + @bool).must == @bool
+      @model.solve!
+    end.should_not raise_error 
+  end
+  
+  it 'should raise error for unsupported right hand sides' do
+    lambda{ @int.must == 'hello' }.should raise_error(TypeError) 
+  end
+  
+  it_should_behave_like 'channel constraint between one int and one bool variable'
+end
+
+describe Gecode::Constraints::Int::Channel, ' (one bool and one int variable)' do
+  before do
+    @model = BoolChannelSampleProblem.new
+    @bool = @model.bool_var
+    @int = @model.int_var
+    
+    @place_constraint = lambda do |bool, int, equals_method_name, negate, options|
+      if negate
+        bool.must_not.method(equals_method_name).call(int, options)
+      else
+        bool.must.method(equals_method_name).call(int, options)
+      end
+    end
+  end
+  
+  it 'should not shadow linear boolean constraints' do
+    lambda do
+      @bool.must == @bool + @bool
+      @model.solve!
+    end.should_not raise_error 
+  end
+  
+  it 'should raise error for unsupported right hand sides' do
+    lambda{ @bool.must == 'hello' }.should raise_error(TypeError) 
+  end
+  
+  it_should_behave_like 'channel constraint between one int and one bool variable'
+end
+
+# Requires @model, @bool_enum and @int. Also requires @place_constraint which 
+# is a method that takes four variables: a boolean enum, an integer variable,
+# whether or not the constraint should be negated and a hash of options, and 
+# places the channel constraint on them.
+describe 'channel constraint between bool enum and int variable', :shared => true do
+  before do
+    @invoke_options = lambda do |hash| 
+      @place_constraint.call(@bools, @int, false, hash)
+      @model.solve!
+    end
+    @expect_options = option_expectation do |strength, kind, reif_var|
+      Gecode::Raw.should_receive(:channel).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        an_instance_of(Gecode::Raw::BoolVarArray),
+        an_instance_of(Gecode::Raw::IntVar), 0,
+        strength, kind)
+    end
+  end
+  
+  it 'should channel the bool enum with the integer variable' do
+    @int.must > 2
+    @place_constraint.call(@bools, @int, false, {})
+    @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
+    @place_constraint.call(@bools, @int, false, :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 not allow negation' do
+    lambda do
+      @place_constraint.call(@bools, @int, true, {})
+    end.should raise_error(Gecode::MissingConstraintError) 
+  end
+  
+  it_should_behave_like 'non-reifiable constraint'
+end
+
+describe Gecode::Constraints::BoolEnum::Channel, ' (bool enum as lhs with int variable)' do
+  before do
+    @model = BoolChannelSampleProblem.new
+    @bools = @model.bool_enum
+    @int = @model.int
+    
+    @place_constraint = lambda do |bools, int, negate, options|
+      unless negate
+        bools.must.channel(int, options)
+      else
+        bools.must_not.channel(int, options)
+      end
+    end
+  end
+
+  it 'should raise error if an integer variable is not given as right hand side' do
+    lambda do
+      @bools.must.channel 'hello'
+    end.should raise_error(TypeError) 
+  end
+  
+  it_should_behave_like 'channel constraint between bool enum and int variable'
+end
+
+
+describe Gecode::Constraints::BoolEnum::Channel, ' (int variable as lhs with bool enum)' do
+  before do
+    @model = BoolChannelSampleProblem.new
+    @bools = @model.bool_enum
+    @int = @model.int
+    
+    @place_constraint = lambda do |bools, int, negate, options|
+      unless negate
+        int.must.channel(bools, options)
+      else
+        int.must_not.channel(bools, options)
+      end
+    end
+  end
+
+  it 'should raise error if a boolean enum is not given as right hand side' do
+    lambda do
+      @int.must.channel 'hello'
+    end.should raise_error(TypeError) 
+  end
+  
+  it_should_behave_like 'channel constraint between bool enum and int variable'
+end

data/specs/constraints/distinct.rb

@@ -8,7 +8,7 @@ class DistinctSampleProblem < Gecode::Model
   def initialize
     @vars = int_var_array(2, 1)
     @sets = set_var_array(2, [], 0..2)
-    branch_on wrap_enum(@sets)
+    branch_on @sets
   end
 end
 

data/specs/constraints/extensional.rb

@@ -1,25 +1,59 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 require File.dirname(__FILE__) + '/constraint_helper'
 
-describe Gecode::Constraints::IntEnum::Extensional do
+# Assumes that @variables, @expected_array and @tuples are defined.
+describe 'tuple constraint', :shared => true do
   before do
-    @model = Gecode::Model.new
-    @tuples = [[1,7], [5,1]]
-    @digits = @model.int_var_array(2, 0..9)
-    @model.branch_on @digits
-    
     @invoke_options = lambda do |hash| 
-      @digits.must_be.in(@tuples, 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), 
-        an_instance_of(Gecode::Raw::IntVarArray), 
+        @expected_array, 
         an_instance_of(Gecode::Raw::TupleSet), strength, kind)
     end
   end
   
+  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
+  
+  it_should_behave_like 'non-reifiable constraint'
+end
+
+describe Gecode::Constraints::IntEnum::Extensional 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
     
@@ -32,12 +66,6 @@ describe Gecode::Constraints::IntEnum::Extensional do
     (found_solutions - @tuples).should be_empty
   end
   
-  it 'should not allow negation' do
-    lambda do 
-      @digits.must_not_be.in @tuples
-    end.should raise_error(Gecode::MissingConstraintError) 
-  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
@@ -46,30 +74,17 @@ describe Gecode::Constraints::IntEnum::Extensional do
     lambda{ @digits.must_be.in [17, 4711] }.should raise_error(TypeError)
   end
   
-  it 'should raise error if the right hand side does not contain integer tuples' do
-    lambda{ @digits.must_be.in ['hello'] }.should raise_error(TypeError)
-  end
-  
-  it_should_behave_like 'non-reifiable constraint'
+  it_should_behave_like 'tuple constraint'
 end
 
 describe Gecode::Constraints::BoolEnum::Extensional do
   before do
     @model = Gecode::Model.new
     @tuples = [[true, false, true], [false, false, true]]
-    @bools = @model.bool_var_array(3)
+    @variables = @bools = @model.bool_var_array(3)
     @model.branch_on @bools
     
-    @invoke_options = lambda do |hash| 
-      @bools.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), 
-        an_instance_of(Gecode::Raw::BoolVarArray), 
-        an_instance_of(Gecode::Raw::TupleSet), strength, kind)
-    end
+    @expected_array = an_instance_of Gecode::Raw::BoolVarArray
   end
   
   it 'should constrain the domain of all variables' do
@@ -84,12 +99,6 @@ describe Gecode::Constraints::BoolEnum::Extensional do
     (found_solutions - @tuples).should be_empty
   end
   
-  it 'should not allow negation' do
-    lambda do 
-      @bools.must_not_be.in @tuples
-    end.should raise_error(Gecode::MissingConstraintError) 
-  end
-  
   it 'should raise error if the right hand side is not an enumeration' do
     lambda{ @bools.must_be.in true }.should raise_error(TypeError)
   end
@@ -98,9 +107,5 @@ describe Gecode::Constraints::BoolEnum::Extensional do
     lambda{ @bools.must_be.in [true, false] }.should raise_error(TypeError)
   end
   
-  it 'should raise error if the right hand side does not contain boolean tuples' do
-    lambda{ @bools.must_be.in ['hello'] }.should raise_error(TypeError)
-  end
-  
-  it_should_behave_like 'non-reifiable constraint'
+  it_should_behave_like 'tuple constraint'
 end

data/specs/constraints/linear.rb

@@ -240,6 +240,14 @@ describe Gecode::Constraints::Int::Linear, '(with booleans)' do
     (x + y).should equal(1)
   end
   
+  it 'should handle singe 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 variables as right hand side' do
     (@x + @y).must == @z
     sol = @model.solve!

data/specs/enum_wrapper.rb

@@ -40,6 +40,13 @@ describe Gecode::Model, ' (enum wrapping)' do
     end.should raise_error(ArgumentError)
   end
   
+  it 'should not allow wrapping a wrapped enumerable' do
+    lambda do 
+      enum = [@bool]
+      @model.wrap_enum(@model.wrap_enum(enum)) 
+    end.should raise_error(ArgumentError)
+  end
+  
   it 'should not allow enumerables without variables or fixnums to be wrapped' do
     lambda do 
       @model.wrap_enum(['foo']) 
@@ -119,4 +126,4 @@ describe Gecode::FixnumEnumMethods do
   it 'should compute the smallest domain range' do
     @enum.domain_range.should == (7..4711)
   end
-end
+end