gecoder-with-gecode 0.9.0-x86-mswin32-60

data/specs/constraints/bool_enum/extensional.rb

@@ -0,0 +1,225 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+# Assumes that @variables, @expected_array and @tuples are defined.
+describe 'bool 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::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
+    
+    @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
+    @bools.must_be.in @tuples
+    
+    found_solutions = []
+    @model.each_solution do |m|
+      found_solutions << @bools.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{ @bools.must_be.in true }.should raise_error(TypeError)
+  end
+  
+  it 'should raise error if the right hand side does not contain tuples' do
+    lambda{ @bools.must_be.in [true, false] }.should raise_error(TypeError)
+  end
+  
+  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 '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
+    @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::BoolEnum::Extensional, ' (regexp constraint)' do
+  before do
+    @model = Gecode::Model.new
+    @variables = @bools = @model.bool_var_array(3)
+    @model.branch_on @bools
+    @expected_array = an_instance_of Gecode::Raw::BoolVarArray
+    @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
+    @bools.must.match [@model.repeat(@model.any(true, false))]
+    @bools[0].must_be.true
+    @bools[1].must_be.false
+    @model.solve!.should_not be_nil
+    @bools[0].value.should be_true
+    @bools[1].value.should be_false
+  end
+
+  it 'should handle the any operator with nested expressions' do
+    @bools.must.match [@model.any(@model.at_least_once(true), [false])]
+    @model.solve!.should_not be_nil
+    @bools.values.should == [true, true, true]
+  end
+
+  it_should_behave_like 'bool regular expression constraint'
+  it_should_behave_like 'non-reifiable constraint'
+end

data/specs/constraints/constraint_helper.rb

@@ -0,0 +1,234 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+# Every constraint should have a spec that specs the following:
+#
+# * An example where the constraint is used to constrain a sample
+# problem (and one for negation if deemed necessary).
+# * should_behave_like [non-reifiable|reifiable] constraint (possibly
+# indirect).
+# * Those constraints that do not support negation must
+# should_behave_like 'non-negatable constraint'
+#
+
+
+# These specs assume that the following variables are defined:
+# [@expect]          A proc that creates an expectation corresponding to
+#                    constraint. It should take three parameter. The
+#                    first is an array of operands of types specified by
+#                    @types. The second is whether or not the constraint
+#                    should be negated. The third is a hash that can
+#                    have values for the keys :icl (ICL_*), :pk (PK_*),
+#                    and :bool (bound reification variable). Any values
+#                    not provided are assumed to be default values (nil
+#                    in the case of :bool).
+# [@invoke]          A proc that invokes the constraint to be tested, It 
+#                    should have arity arity(@types) + 1. The first
+#                    parameter is a constraint receiver (type decided by 
+#                    @types). The next arity(@types)-1 parameters are 
+#                    given operands of types specified by @types. The
+#                    last parameter is a hash of options (with at most
+#                    the keys :strength, :kind and :reify)..
+# [@types]           An array of symbols signaling what types of
+#                    arguments @ accepts. The symbols
+#                    must be one of: :int, :bool, :set, :int_enum,
+#                    :bool_enum, :set_enum, :fixnum_enum.
+# [@model]           The model instance that contains the aspects being tested.
+
+def expect(variables, options)
+  bool = options[:bool]
+  bool = @model.allow_space_access{ bool.bind } unless bool.nil?
+  args = @model.allow_space_access do 
+    variables.map do |var| 
+      if var.respond_to? :bind
+        var.bind
+      else
+        var.bind_array
+      end
+    end
+  end
+  args << [options[:icl] || Gecode::Raw::ICL_DEF,
+           options[:pk]  || Gecode::Raw::PK_DEF]
+  args << bool
+  @expect.call(*args)
+end
+
+def invoke(operands, options)
+  base_op = operands.first
+  if options.delete(:negate)
+    receiver = base_op.must_not
+  else
+    receiver = base_op.must
+  end
+  args = ([receiver] + operands[1..-1]) << options
+  @invoke.call(*args)
+end
+
+describe 'reifiable constraint', :shared => true do
+  it_should_behave_like 'constraint with default options'
+  it_should_behave_like 'constraint with reification option'
+  it_should_behave_like 'constraint'
+end
+
+describe 'non-reifiable constraint', :shared => true do
+  it 'should raise errors if reification is used' do
+    operands, variables = produce_general_arguments(@types)
+    lambda do 
+      invoke(operands, :reify => @model.bool_var)
+    end.should raise_error(ArgumentError)
+  end
+
+  it_should_behave_like 'constraint with default options'
+  it_should_behave_like 'constraint'
+end
+
+describe 'non-negatable constraint', :shared => true do
+  it 'should raise errors if negation is used' do
+    operands, variables = produce_general_arguments(@types)
+    lambda do 
+      invoke(operands, :negate => true)
+    end.should raise_error(Gecode::MissingConstraintError)
+  end
+end
+
+describe 'constraint', :shared => true do
+  it 'should raise errors if parameters of the incorrect type are given' do
+    operands, variables = produce_general_arguments(@types)
+    (1...operands.size).each do |i|
+      bogus_operands = operands.clone
+      bogus_operands[i] = Object.new
+      lambda do
+        invoke(bogus_operands, {})
+      end.should raise_error(TypeError)
+    end
+  end
+end
+
+describe 'constraint with reification option', :shared => true do
+  it 'should translate reification' do
+    operands, variables = produce_general_arguments(@types)
+    var = @model.bool_var
+    expect(variables, :bool => var)
+    invoke(operands, :reify => var)
+  end
+
+  it 'should translate reification with arbitrary bool operand' do
+    operands, variables = produce_general_arguments(@types)
+    op, bool_var = general_bool_operand(@model)
+    expect(variables, :bool => bool_var)
+    invoke(operands, :reify => op)
+  end
+  
+  it 'should raise errors for reification variables of incorrect type' do
+    operands, variables = produce_general_arguments(@types)
+    lambda do 
+      invoke(operands, :reify => 'foo')
+    end.should raise_error(TypeError)
+  end
+end
+
+describe 'constraint with default options', :shared => true do
+  it 'should raise errors for unrecognized options' do
+    operands, variables = produce_general_arguments(@types)
+    lambda do 
+      invoke(operands, :does_not_exist => :foo) 
+    end.should raise_error(ArgumentError)
+  end
+
+  it_should_behave_like 'constraint with strength option'
+  it_should_behave_like 'constraint with kind option'
+end
+
+describe 'constraint with strength option', :shared => true do
+  { :default  => Gecode::Raw::ICL_DEF,
+    :value    => Gecode::Raw::ICL_VAL,
+    :bounds   => Gecode::Raw::ICL_BND,
+    :domain   => Gecode::Raw::ICL_DOM
+  }.each_pair do |name, gecode_value|
+    it "should translate propagation strength #{name}" do
+      operands, variables = produce_general_arguments(@types)
+      expect(variables, :icl => gecode_value)
+      invoke(operands, :strength => name)
+    end
+  end
+  
+  it 'should default to using default as propagation strength' do
+    operands, variables = produce_general_arguments(@types)
+    expect(variables, {})
+    invoke(operands, {})
+  end
+  
+  it 'should raise errors for unrecognized propagation strengths' do
+    operands, variables = produce_general_arguments(@types)
+    lambda do 
+      invoke(operands, :strength => :does_not_exist) 
+    end.should raise_error(ArgumentError)
+  end
+end
+
+describe 'constraint with kind option', :shared => true do
+  { :default  => Gecode::Raw::PK_DEF,
+    :speed    => Gecode::Raw::PK_SPEED,
+    :memory   => Gecode::Raw::PK_MEMORY
+  }.each_pair do |name, gecode_value|
+    it "should translate propagation kind #{name}" do
+      operands, variables = produce_general_arguments(@types)
+      expect(variables, :pk => gecode_value)
+      invoke(operands, :kind => name)
+    end
+  end
+  
+  it 'should default to using default as propagation kind' do
+    operands, variables = produce_general_arguments(@types)
+    expect(variables, {})
+    invoke(operands, {})
+  end
+  
+  it 'should raise errors for unrecognized propagation kinds' do
+    operands, variables = produce_general_arguments(@types)
+    lambda do 
+      invoke(operands, :kind => :does_not_exist)
+    end.should raise_error(ArgumentError)
+  end
+end
+
+describe 'set constraint', :shared => true do
+  it 'should not accept strength option' do
+    operands, variables = produce_general_arguments(@types)
+    lambda do 
+      invoke(operands, :strength => :default)
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should not accept kind option' do
+    operands, variables = produce_general_arguments(@types)
+    lambda do 
+      invoke(operands, :kind => :default)
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should raise errors for unrecognized options' do
+    operands, variables = produce_general_arguments(@types)
+    lambda do 
+      invoke(operands, :does_not_exist => :foo) 
+    end.should raise_error(ArgumentError)
+  end
+
+  it_should_behave_like 'constraint'
+end
+
+describe 'non-reifiable set constraint', :shared => true do
+  it 'should not accept reification option' do
+    bool = @model.bool_var
+    operands, variables = produce_general_arguments(@types)
+    lambda do 
+      invoke(operands, :reify => bool)
+    end.should raise_error(ArgumentError)
+  end
+  
+  it_should_behave_like 'set constraint'
+end
+
+describe 'reifiable set constraint', :shared => true do
+  it_should_behave_like 'set constraint'
+  it_should_behave_like 'constraint with reification option'
+end