gecoder 0.8.3 → 0.9.0

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
+

data/specs/constraints/int_enum/sort.rb

@@ -0,0 +1,167 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+class SortSampleProblem < Gecode::Model
+  attr :vars
+  attr :sorted
+  attr :indices
+  
+  def initialize
+    @vars = int_var_array(4, 10..19)
+    @sorted = int_var_array(4, 10..19)
+    @indices = int_var_array(4, 0..9)
+    
+    # To make it more interesting
+    @vars.must_be.distinct
+    
+    branch_on @vars
+  end
+end
+
+describe Gecode::IntEnum::Sort, ' (without :as and :order)' do
+  before do
+    @model = SortSampleProblem.new
+    @vars = @model.vars
+    @sorted = @model.sorted
+    
+    @types = [:int_enum]
+    @invoke = lambda do |receiver, hash| 
+      receiver.sorted(hash)
+      @model.solve!
+    end
+    @expect = lambda do |var, opts, reif_var|
+      if reif_var.nil?
+        Gecode::Raw.should_receive(:rel).exactly(var.size - 1).times.with(
+          an_instance_of(Gecode::Raw::Space), 
+          an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_LQ,
+          an_instance_of(Gecode::Raw::IntVar), *opts)
+      else
+        Gecode::Raw.should_receive(:rel).once.with(
+          an_instance_of(Gecode::Raw::Space), anything, 
+          an_instance_of(Gecode::Raw::BoolVarArray), 
+          anything, anything, anything)
+        Gecode::Raw.should_receive(:rel).exactly(var.size - 1).times.with(
+          an_instance_of(Gecode::Raw::Space), 
+          an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_LQ,
+          an_instance_of(Gecode::Raw::IntVar),
+          an_instance_of(Gecode::Raw::BoolVar), *opts)
+      end
+    end
+  end
+  
+  it 'should constraint variables to be sorted' do
+    @vars.must_be.sorted
+    values = @model.solve!.vars.values
+    values.should == values.sort
+  end
+  
+  it 'should allow negation' do
+    @vars.must_not_be.sorted
+    @model.solve!
+    values = @vars.values
+    values.should_not == values.sort
+  end
+  
+  it_should_behave_like 'reifiable constraint'
+end
+
+describe Gecode::IntEnum::Sort, ' (with :as)' do
+  before do
+    @model = SortSampleProblem.new
+    @vars = @model.vars
+    @sorted = @model.sorted
+    
+    # Make it a bit more interesting.
+    @vars[0].must > @vars[3] + 1
+    
+    @types = [:int_enum, :int_enum]
+    @invoke = lambda do |receiver, int_enum, hash| 
+      receiver.sorted hash.update(:as => int_enum)
+      @model.solve!
+    end
+    @expect = lambda do |var1, var2, opts, reif_var|
+      Gecode::Raw.should_receive(:sorted).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        var1, var2, *opts)
+    end
+  end
+  
+  it 'should constraint variables to be sorted' do
+    @vars.must_be.sorted(:as => @sorted)
+    @model.solve!
+    values = @sorted.values
+    values.should == values.sort
+  end
+   
+  it_should_behave_like 'non-reifiable constraint'
+  it_should_behave_like 'non-negatable constraint'
+end
+
+describe Gecode::IntEnum::Sort, ' (with :order)' do
+  before do
+    @model = SortSampleProblem.new
+    @vars = @model.vars
+    @sorted = @model.sorted
+    @indices = @model.indices
+    
+    # Make it a bit more interesting.
+    @vars[0].must > @vars[3] + 1
+    
+    @types = [:int_enum, :int_enum]
+    @invoke = lambda do |receiver, int_enum, hash| 
+      receiver.sorted hash.update(:order => int_enum)
+      @model.solve!
+    end
+    @expect = lambda do |var1, var2, opts, reif_var|
+      Gecode::Raw.should_receive(:sorted).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        var1, an_instance_of(Gecode::Raw::IntVarArray), var2,
+        *opts)
+    end
+  end
+  
+  it 'should constraint variables to be sorted with the specified indices' do
+    @vars.must_be.sorted(:order => @indices)
+    @model.solve!
+    sorted_values = @vars.values.sort
+    expected_indices = @vars.map{ |v| sorted_values.index(v.value) }
+    @indices.values.should == expected_indices
+  end
+  
+  it_should_behave_like 'non-reifiable constraint'
+  it_should_behave_like 'non-negatable constraint'
+end
+
+describe Gecode::IntEnum::Sort, ' (with :order and :as)' do
+  before do
+    @model = SortSampleProblem.new
+    @vars = @model.vars
+    @sorted = @model.sorted
+    @indices = @model.indices
+    
+    # Make it a bit more interesting.
+    @vars[0].must > @vars[3] + 1
+    
+    @types = [:int_enum, :int_enum, :int_enum]
+    @invoke = lambda do |receiver, int_enum1, int_enum2, hash| 
+      receiver.sorted hash.update(:as => int_enum1, :order => int_enum2)
+      @model.solve!
+    end
+    @expect = lambda do |var1, var2, var3, opts, reif_var|
+      Gecode::Raw.should_receive(:sorted).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        var1, var2, var3, *opts)
+    end
+  end
+  
+  it 'should constraint variables to be sorted with the specified indices' do
+    @vars.must_be.sorted(:as => @sorted, :order => @indices)
+    @model.solve!
+    sorted_values = @sorted.values
+    sorted_values.should == sorted_values.sort
+    expected_indices = @vars.map{ |v| sorted_values.index(v.value) }
+    @indices.values.should == expected_indices
+  end
+  
+  it_should_behave_like 'non-reifiable constraint'
+  it_should_behave_like 'non-negatable constraint'
+end

data/specs/constraints/operands.rb

@@ -0,0 +1,264 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe 'operand', :shared => true do
+  it 'should not shadow method missing' do
+    lambda do
+      @operand.does_not_exist
+    end.should raise_error(NoMethodError)
+  end
+end
+
+describe 'variable operand', :shared => true do
+  it 'should fall back to the underlying variable' do
+    lambda do 
+      @operand.assigned?
+    end.should_not raise_error
+  end
+
+  it_should_behave_like 'operand'
+end
+
+describe 'enum operand', :shared => true do
+  it 'should fall back to the underlying enum' do
+    lambda do 
+      @operand[0]
+    end.should_not raise_error
+  end
+
+  it_should_behave_like 'operand'
+end
+
+describe Gecode::Operand do
+  before do
+    model = Gecode::Model.new
+    @operand = Object.new
+    class <<@operand
+      include Gecode::Operand
+    end
+  end
+
+  it 'should raise error if #model is not defined' do
+    lambda do
+      @operand.model
+    end.should raise_error(NotImplementedError)
+  end
+
+  it 'should raise error if #construct_receiver is not defined' do
+    lambda do
+      @operand.must
+    end.should raise_error(NotImplementedError)
+  end
+end
+
+describe Gecode::Int::IntOperand do
+  before do
+    model = Gecode::Model.new
+    @operand, _ = general_int_operand(model)
+  end
+
+  it_should_behave_like 'variable operand'
+end
+
+describe Gecode::Int::ShortCircuitEqualityOperand, ' (not subclassed)' do
+  before do
+    @model = Gecode::Model.new
+    @operand = Gecode::Int::ShortCircuitEqualityOperand.new(@model)
+  end
+
+  it 'should raise error if #constrain_equal is called' do
+    lambda do
+      @operand.to_int_var
+      @model.solve!
+    end.should raise_error(NotImplementedError)
+  end
+end
+
+describe Gecode::Int::ShortCircuitRelationsOperand, ' (not subclassed)' do
+  before do
+    @model = Gecode::Model.new
+    @operand = Gecode::Int::ShortCircuitRelationsOperand.new(@model)
+  end
+
+  it 'should raise error if #constrain_equal is called' do
+    lambda do
+      @operand.to_int_var
+      @model.solve!
+    end.should raise_error(NotImplementedError)
+  end
+end
+
+describe Gecode::IntEnum::IntEnumOperand do
+  before do
+    model = Gecode::Model.new
+    @operand, _ = general_int_enum_operand(model)
+  end
+
+  it_should_behave_like 'enum operand'
+end
+
+describe Gecode::Bool::BoolOperand do
+  before do
+    model = Gecode::Model.new
+    @operand, _ = general_bool_operand(model)
+  end
+
+  it_should_behave_like 'variable operand'
+end
+
+describe Gecode::Bool::ShortCircuitEqualityOperand, ' (not subclassed)' do
+  before do
+    @model = Gecode::Model.new
+    @operand = Gecode::Bool::ShortCircuitEqualityOperand.new(@model)
+  end
+
+  it 'should raise error if #constrain_equal is called' do
+    lambda do
+      @operand.to_bool_var
+      @model.solve!
+    end.should raise_error(NotImplementedError)
+  end
+end
+
+describe Gecode::BoolEnum::BoolEnumOperand do
+  before do
+    model = Gecode::Model.new
+    @operand, _ = general_bool_enum_operand(model)
+  end
+
+  it_should_behave_like 'enum operand'
+end
+
+describe Gecode::Set::SetOperand do
+  before do
+    model = Gecode::Model.new
+    @operand, _ = general_set_operand(model)
+  end
+
+  it_should_behave_like 'variable operand'
+end
+
+describe Gecode::Set::ShortCircuitEqualityOperand, ' (not subclassed)' do
+  before do
+    @model = Gecode::Model.new
+    @operand = Gecode::Set::ShortCircuitEqualityOperand.new(@model)
+  end
+
+  it 'should raise error if #constrain_equal is called' do
+    lambda do
+      @operand.to_set_var
+      @model.solve!
+    end.should raise_error(NotImplementedError)
+  end
+end
+
+describe Gecode::Set::ShortCircuitRelationsOperand, ' (not subclassed)' do
+  before do
+    @model = Gecode::Model.new
+    @operand = Gecode::Set::ShortCircuitRelationsOperand.new(@model)
+  end
+
+  it 'should raise error if #constrain_equal is called' do
+    lambda do
+      @operand.to_set_var
+      @model.solve!
+    end.should raise_error(NotImplementedError)
+  end
+end
+
+describe Gecode::SelectedSet::SelectedSetOperand do
+  before do
+    model = Gecode::Model.new
+    @operand, ops = general_selected_set_operand(model)
+    @enum, @set = ops
+  end
+
+  it 'should raise error if set enum operand is not given' do
+    lambda do
+      Gecode::SelectedSet::SelectedSetOperand.new(:foo, @set)
+    end.should raise_error(TypeError)
+  end
+
+  it 'should raise error if set operand is not given' do
+    lambda do
+      Gecode::SelectedSet::SelectedSetOperand.new(@enum, :foo)
+    end.should raise_error(TypeError)
+  end
+
+  it_should_behave_like 'operand'
+end
+
+describe Gecode::SetElements::SetElementsOperand do
+  before do
+    model = Gecode::Model.new
+    @operand, @set = general_set_elements_operand(model)
+  end
+
+  it 'should raise error if set operand is not given' do
+    lambda do
+      Gecode::SetElements::SetElementsOperand.new(:foo)
+    end.should raise_error(TypeError)
+  end
+
+  it_should_behave_like 'operand'
+end
+
+describe Gecode::SetEnum::SetEnumOperand do
+  before do
+    model = Gecode::Model.new
+    @operand, _ = general_set_enum_operand(model)
+  end
+
+  it_should_behave_like 'enum operand'
+end
+
+describe Gecode::FixnumEnum::FixnumEnumOperand do
+  before do
+    model = Gecode::Model.new
+    @operand, _ = general_fixnum_enum_operand(model)
+  end
+
+  it 'should raise error if constraint receiver is called' do
+    lambda do
+      @operand.must
+    end.should raise_error(NotImplementedError)
+  end
+
+  it_should_behave_like 'enum operand'
+end
+
+# High level sanity check.
+describe 'operand combination' do
+  it 'should allow placing constraints on complicated combinations of operands' do
+    model = Gecode::Model.new
+    sets = model.set_var_array(2, [], 0..9)
+    set1, set2 = sets
+    (set1.size + set2.size).must == 5
+    set1.size.must > 1
+    set2.size.must > 1
+    model.branch_on sets
+
+    model.solve!
+
+    (set1.value.size + set2.value.size).should == 5
+    set1.value.size.should > 1
+    set2.value.size.should > 1
+  end
+
+  it 'should allow placing constraints on complicated combinations of operands (2)' do
+    model = Gecode::Model.new
+    sets = model.set_var_array(3, [], 0..9)
+    set1, set2, set3 = sets
+    (set1.size + set2.size).must == (set3.size - set1.max)
+    set3.size.must > 3
+    set2.size.must < 3
+    set1.size.must > 0
+    model.branch_on sets
+
+    model.solve!
+
+    (set1.value.size + set2.value.size).should == (set3.value.size - set1.value.max)
+    set3.value.size.should > 3
+    set2.value.size.should < 3
+    set1.value.size.should > 0
+  end
+end