gecoder-with-gecode 0.7.1-mswin32

data/specs/constraints/arithmetic.rb

@@ -0,0 +1,266 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
+
+class ArithmeticSampleProblem < Gecode::Model
+  attr :numbers
+  attr :var
+  attr :var2
+  attr :var3
+  
+  def initialize
+    @numbers = int_var_array(4, 0..9)
+    @var = int_var(-9..9)
+    @var2 = int_var(0..9)
+    @var3 = int_var(0..9)
+    branch_on @numbers
+    branch_on wrap_enum([@var, @var2, @var3])
+  end
+end
+
+# Requires @stub, @target, @model and @expect.
+describe 'arithmetic constraint', :shared => true do
+  before do
+    # For constraint option spec.
+    @invoke_options = lambda do |hash| 
+      @stub.must_be.greater_than(@target, hash) 
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      @expect.call(Gecode::Raw::IRT_GR, @target, strength, reif_var, false)
+    end
+    
+    # For composite spec.
+    @invoke_relation = lambda do |relation, target, negated|
+      if negated
+        @stub.must_not.send(relation, target)
+      else
+        @stub.must.send(relation, target)
+      end
+      @model.solve!
+    end
+    @expect_relation = lambda do |relation, target, negated|
+      @expect.call(relation, target, Gecode::Raw::ICL_DEF, nil, negated)
+    end
+  end
+  
+  it 'should translate reification when using equality' do
+    bool_var = @model.bool_var
+    @expect.call(Gecode::Raw::IRT_EQ, @target, Gecode::Raw::ICL_DEF, bool_var, 
+      false)
+    @stub.must_be.equal_to(@target, :reify => bool_var)
+    @model.solve!
+  end
+  
+  it_should_behave_like 'composite constraint'
+  it_should_behave_like 'constraint with options'
+end
+
+describe Gecode::Constraints::IntEnum::Arithmetic, ' (max)' do
+  before do
+    @model = ArithmeticSampleProblem.new
+    @numbers = @model.numbers
+    @target = @var = @model.var
+    @stub = @numbers.max
+    
+    # Creates an expectation corresponding to the specified input.
+    @expect = lambda do |relation, rhs, strength, 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(:max).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVarArray), rhs, strength)
+            Gecode::Raw.should_receive(:rel).exactly(0).times
+          else
+            Gecode::Raw.should_receive(:max).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVarArray), 
+              an_instance_of(Gecode::Raw::IntVar), strength)
+            Gecode::Raw.should_receive(:rel).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+          end
+        else
+          Gecode::Raw.should_receive(:max).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::IntVarArray), 
+            an_instance_of(Gecode::Raw::IntVar), strength)
+          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)
+        end
+      end
+    end
+  end
+  
+  it 'should constrain the maximum value' do
+    @numbers.max.must > 5
+    @model.solve!.numbers.values.max.should > 5
+  end
+  
+  it_should_behave_like 'arithmetic constraint'
+end
+
+describe Gecode::Constraints::IntEnum::Arithmetic, ' (min)' do
+  before do
+    @model = ArithmeticSampleProblem.new
+    @numbers = @model.numbers
+    @target = @var = @model.var
+    @stub = @numbers.min
+    
+    # Creates an expectation corresponding to the specified input.
+    @expect = lambda do |relation, rhs, strength, 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(:min).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVarArray), rhs, strength)
+            Gecode::Raw.should_receive(:rel).exactly(0).times
+          else
+            Gecode::Raw.should_receive(:min).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVarArray), 
+              an_instance_of(Gecode::Raw::IntVar), strength)
+            Gecode::Raw.should_receive(:rel).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+          end
+        else
+          Gecode::Raw.should_receive(:min).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::IntVarArray), 
+            an_instance_of(Gecode::Raw::IntVar), strength)
+          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)
+        end
+      end
+    end
+  end
+  
+  it 'should constrain the minimum value' do
+    @numbers.min.must > 5
+    @model.solve!.numbers.values.min.should > 5
+  end
+  
+  it_should_behave_like 'arithmetic constraint'
+end
+
+describe Gecode::Constraints::Int::Arithmetic, ' (abs)' do
+  before do
+    @model = ArithmeticSampleProblem.new
+    @var = @model.var
+    @target = @model.var2
+    @stub = @var.abs
+    
+    # Creates an expectation corresponding to the specified input.
+    @expect = lambda do |relation, rhs, strength, 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(:abs).once.with(
+              an_instance_of(Gecode::Raw::Space),
+              an_instance_of(Gecode::Raw::IntVar), rhs, strength)
+            Gecode::Raw.should_receive(:rel).exactly(0).times
+          else
+            Gecode::Raw.should_receive(:abs).once.with(
+              an_instance_of(Gecode::Raw::Space),
+              an_instance_of(Gecode::Raw::IntVar), 
+              an_instance_of(Gecode::Raw::IntVar), strength)
+            Gecode::Raw.should_receive(:rel).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+          end
+        else
+          Gecode::Raw.should_receive(:abs).once.with(
+            an_instance_of(Gecode::Raw::Space),
+            an_instance_of(Gecode::Raw::IntVar), 
+            an_instance_of(Gecode::Raw::IntVar), strength)
+          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)
+        end
+      end
+    end
+  end
+  
+  it 'should constrain the absolute value' do
+    @var.must < 0
+    @var.abs.must == 5
+    @model.solve!.var.value.should == -5
+  end
+  
+  it_should_behave_like 'arithmetic constraint'
+end
+
+describe Gecode::Constraints::Int::Arithmetic, ' (multiplication)' do
+  before do
+    @model = ArithmeticSampleProblem.new
+    @var = @model.var
+    @var2 = @model.var2
+    @stub = @var * @var2
+    @target = @model.var3
+    
+    # Creates an expectation corresponding to the specified input.
+    @expect = lambda do |relation, rhs, strength, 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)
+            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)
+            Gecode::Raw.should_receive(:rel).once.with(
+              an_instance_of(Gecode::Raw::Space), 
+              an_instance_of(Gecode::Raw::IntVar), relation, rhs, strength)
+          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)
+          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)
+        end
+      end
+    end
+  end
+  
+  it 'should constrain the value of the multiplication' do
+    (@var * @var2).must == 56
+    sol = @model.solve!
+    [sol.var.value, sol.var2.value].sort.should == [7, 8]
+  end
+  
+  it 'should not interfere with other defined multiplication methods' do
+    (@var * :foo).should be_nil
+  end
+  
+  it_should_behave_like 'arithmetic constraint'
+end

data/specs/constraints/bool_enum.rb

@@ -0,0 +1,140 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_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 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::Constraints::BoolEnum, ' (conjunction)' do
+  before do
+    @model = BoolEnumSampleProblem.new
+    @bools = @model.bools
+    @b1 = @model.b1
+    @b2 = @model.b2
+    
+    # For constraint option spec.
+    @invoke_options = lambda do |hash| 
+      @bools.conjunction.must_be.equal_to(true, hash) 
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      @model.allow_space_access do
+        Gecode::Raw.should_receive(:bool_and).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          an_instance_of(Gecode::Raw::BoolVarArray), 
+          an_instance_of(Gecode::Raw::BoolVar), strength)
+        unless reif_var.nil?
+          Gecode::Raw.should_receive(:bool_eqv).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::BoolVar), 
+            an_instance_of(Gecode::Raw::BoolVar), true, strength)
+        end
+      end
+    end
+    
+    # For bool enum spec.
+    @stub = @bools.conjunction
+    @compute_result = lambda{ @bools.all?{ |b| b.value } }
+  end
+  
+  it_should_behave_like 'bool enum constraint'
+  it_should_behave_like 'constraint with options'
+end
+
+describe Gecode::Constraints::BoolEnum, ' (disjunction)' do
+  before do
+    @model = BoolEnumSampleProblem.new
+    @bools = @model.bools
+    @b1 = @model.b1
+    @b2 = @model.b2
+    
+    # For constraint option spec.
+    @invoke_options = lambda do |hash| 
+      @bools.disjunction.must_be.equal_to(true, hash) 
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      @model.allow_space_access do
+        Gecode::Raw.should_receive(:bool_or).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          an_instance_of(Gecode::Raw::BoolVarArray), 
+          an_instance_of(Gecode::Raw::BoolVar), strength)
+        unless reif_var.nil?
+          Gecode::Raw.should_receive(:bool_eqv).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::BoolVar), 
+            an_instance_of(Gecode::Raw::BoolVar), true, strength)
+        end
+      end
+    end
+    
+    # For bool enum spec.
+    @stub = @bools.disjunction
+    @compute_result = lambda{ @bools.any?{ |b| b.value } }
+  end
+  
+  it_should_behave_like 'bool enum constraint'
+  it_should_behave_like 'constraint with options'
+end

data/specs/constraints/boolean.rb

@@ -0,0 +1,232 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
+
+class BoolSampleProblem < Gecode::Model
+  attr :b1
+  attr :b2
+  attr :b3
+  
+  def initialize
+    @b1 = self.bool_var
+    @b2 = self.bool_var
+    @b3 = self.bool_var
+  end
+end
+
+describe Gecode::Constraints::Bool do
+  before do
+    @model = BoolSampleProblem.new
+    @b1 = @model.b1
+    @b2 = @model.b2
+    @b3 = @model.b3
+    
+    # For constraint option spec.
+    @invoke_options = lambda do |hash| 
+      (@b1 | @b2).must_be.equal_to(true, hash) 
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      @model.allow_space_access do
+        Gecode::Raw.should_receive(:bool_or).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          an_instance_of(Gecode::Raw::BoolVar), 
+          an_instance_of(Gecode::Raw::BoolVar), 
+          an_instance_of(Gecode::Raw::BoolVar), 
+          Gecode::Raw::ICL_DEF)
+        unless reif_var.nil?
+          Gecode::Raw.should_receive(:bool_eqv).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::BoolVar), 
+            an_instance_of(Gecode::Raw::BoolVar), true, strength)
+        end
+      end
+    end
+  end
+  
+  it 'should handle single variables constrainted to be true' do
+    @b1.must_be.true
+    b1 = @model.solve!.b1
+    b1.should be_assigned
+    b1.value.should be_true
+  end
+  
+  it 'should handle single variables constrainted to be false' do
+    @b1.must_be.false
+    b1 = @model.solve!.b1
+    b1.should be_assigned
+    b1.value.should_not be_true
+  end
+  
+  it 'should handle single variables constrainted not to be false' do
+    @b1.must_not_be.false
+    b1 = @model.solve!.b1
+    b1.should be_assigned
+    b1.value.should be_true
+  end
+  
+  it 'should handle single variables constrainted not to be true' do
+    @b1.must_not_be.true
+    b1 = @model.solve!.b1
+    b1.should be_assigned
+    b1.value.should_not be_true
+  end
+
+  it 'should handle disjunction' do
+    @b1.must_be.false
+    (@b1 | @b2).must_be.true
+    sol = @model.solve!
+    sol.b1.value.should_not be_true
+    sol.b2.value.should be_true
+  end
+  
+  it 'should handle negated disjunction' do
+    @b1.must_be.false
+    (@b1 | @b2).must_not_be.true
+    sol = @model.solve!
+    sol.b1.value.should_not be_true
+    sol.b2.value.should_not be_true
+  end
+  
+  it 'should handle conjunction' do
+    (@b1 & @b2).must_be.true
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should be_true
+  end
+
+  it 'should handle negated conjunction' do
+    @b1.must_be.true
+    (@b1 & @b2).must_not_be.true
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should_not be_true
+  end
+
+  it 'should handle exclusive or' do
+    @b1.must_be.false
+    (@b1 ^ @b2).must_be.true
+    sol = @model.solve!
+    sol.b1.value.should_not be_true
+    sol.b2.value.should be_true
+  end
+
+  it 'should handle negated exclusive or' do
+    @b1.must_be.true
+    (@b1 ^ @b2).must_not_be.true
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should be_true
+  end
+  
+  it 'should handle implication' do
+    @b2.must_be.false
+    (@b1.implies @b2).must_be.true
+    sol = @model.solve!
+    sol.b1.value.should_not be_true
+    sol.b2.value.should_not be_true
+  end
+  
+  it 'should handle negated implication' do
+    @b1.must_be.true
+    ((@b1 | @b2).implies @b2).must_not_be.true
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should_not be_true
+  end
+  
+  it 'should handle imply after must' do
+    @b2.must_be.false
+    @b1.must.imply @b2
+    sol = @model.solve!
+    sol.b1.value.should_not be_true
+    sol.b2.value.should_not be_true
+  end
+  
+  it 'should handle imply after must_not' do
+    @b1.must_be.true
+    @b1.must_not.imply @b2
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should_not be_true
+  end
+
+  it 'should handle single variables as right hand side' do
+    @b1.must == @b2
+    @b2.must_be.false
+    sol = @model.solve!
+    sol.b1.value.should_not be_true
+    sol.b2.value.should_not be_true
+  end
+  
+  it 'should handle single variables with negation as right hand side' do
+    @b1.must_not == @b2
+    @b2.must_be.false
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should_not be_true
+  end
+  
+  it 'should handle expressions as right hand side' do
+    @b1.must == (@b2 | @b3)
+    @b2.must_be.true
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should be_true
+  end
+  
+  it 'should handle nested expressions as left hand side' do
+    ((@b1 & @b2) | @b3 | (@b1 & @b3)).must_be.true
+    @b1.must_be.false
+    sol = @model.solve!
+    sol.b1.value.should_not be_true
+    sol.b3.value.should be_true
+  end
+  
+  it 'should handle nested expressions on both side' do
+    ((@b1 & @b1) | @b3).must == ((@b1 & @b3) & @b2)
+    @b1.must_be.true
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should be_true
+    sol.b3.value.should be_true
+  end
+  
+  it 'should handle nested expressions containing exclusive or' do
+    ((@b1 ^ @b1) & @b3).must == ((@b2 | @b3) ^ @b2)
+    @b1.must_be.true
+    @b2.must_be.false
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should_not be_true
+    sol.b3.value.should_not be_true
+  end
+  
+  it 'should handle nested expressions on both sides with negation' do
+    ((@b1 & @b1) | @b3).must_not == ((@b1 | @b3) & @b2)
+    @b1.must_be.true
+    @b3.must_be.true
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should_not be_true
+    sol.b3.value.should be_true
+  end
+  
+  it 'should translate reification with a variable right hand side' do
+    @b1.must_be.equal_to(@b2, :reify => @b3)
+    @b1.must_be.true
+    @b2.must_be.false
+    sol = @model.solve!
+    sol.b3.value.should_not be_true
+  end
+  
+  it 'should translate reification with a variable right hand side and negation' do
+    @b1.must_not_be.equal_to(@b2, :reify => @b3)
+    @b1.must_be.true
+    @b2.must_be.false
+    sol = @model.solve!
+    sol.b3.value.should be_true
+  end
+  
+  
+  it_should_behave_like 'constraint with options'
+end