gecoder-with-gecode 0.7.1

data/specs/constraints/constraint_helper.rb

@@ -0,0 +1,180 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+# This requires that the constraint spec has instance variables @invoke_options
+# and @expect_options .
+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
+      @expect_options.call(gecode_value, nil)
+      @invoke_options.call(:strength => name)
+    end
+  end
+  
+  it 'should default to using default as propagation strength' do
+    @expect_options.call(Gecode::Raw::ICL_DEF, nil)
+    @invoke_options.call({})
+  end
+  
+  it 'should raise errors for unrecognized options' do
+    lambda{ @invoke_options.call(:does_not_exist => :foo) }.should(
+      raise_error(ArgumentError))
+  end
+  
+  it 'should raise errors for unrecognized propagation strengths' do
+    lambda{ @invoke_options.call(:strength => :does_not_exist) }.should(
+      raise_error(ArgumentError))
+  end
+  
+  it 'should raise errors for reification variables of incorrect type' do
+    lambda{ @invoke_options.call(:reify => 'foo') }.should(
+      raise_error(TypeError))
+  end
+end
+
+# This requires that the constraint spec has instance variables @invoke_options
+# and @expect_options .
+describe 'constraint with options', :shared => true do
+  it 'should translate reification' do
+    var = @model.bool_var
+    @expect_options.call(Gecode::Raw::ICL_DEF, var)
+    @invoke_options.call(:reify => var)
+  end
+  
+  it_should_behave_like 'constraint with strength option'
+end
+
+# This requires that the constraint spec has the instance variable 
+# @expect_relation which takes a relation, right hand side and whether it's 
+# negated as arguments and sets up the corresponding expectations. It also 
+# requires @invoke_relation with the same arguments. The spec is also required 
+# to provide a variable @target.
+describe 'composite constraint', :shared => true do
+  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
+    it "should translate #{relation} with constant target" do
+      @expect_relation.call(type, 1, false)
+      @invoke_relation.call(relation, 1, false)
+    end
+  end
+  
+  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
+    it "should translate #{relation} with variable target" do
+      @expect_relation.call(type, @target, false)
+      @invoke_relation.call(relation, @target, false)
+    end
+  end
+  
+  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate negated #{relation} with constant target" do
+      @expect_relation.call(type, 1, true)
+      @invoke_relation.call(relation, 1, true)
+    end
+  end
+  
+  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate negated #{relation} with variable target" do
+      @expect_relation.call(type, @target, true)
+      @invoke_relation.call(relation, @target, true)
+    end
+  end
+
+  it 'should raise error if the target is of the wrong type' do
+    lambda do 
+      @invoke_relation.call(:==, 'hello', false)
+    end.should raise_error(TypeError) 
+  end
+end
+
+# This requires that the constraint spec has the instance variable 
+# @expect_relation which takes a relation, right hand side and whether it's 
+# negated as arguments and sets up the corresponding expectations. It also 
+# requires @invoke_relation with the same arguments. The spec is also required 
+# to provide a variable @target.
+describe 'composite set constraint', :shared => true do
+  Gecode::Constraints::Util::SET_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate #{relation} with constant target" do
+      @expect_relation.call(type, [1], false)
+      @invoke_relation.call(relation, [1], false)
+    end
+  end
+  
+  Gecode::Constraints::Util::SET_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate #{relation} with variable target" do
+      @expect_relation.call(type, @target, false)
+      @invoke_relation.call(relation, @target, false)
+    end
+  end
+  
+  Gecode::Constraints::Util::NEGATED_SET_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate negated #{relation} with constant target" do
+      @expect_relation.call(type, [1], true)
+      @invoke_relation.call(relation, [1], true)
+    end
+  end
+  
+  Gecode::Constraints::Util::NEGATED_SET_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate negated #{relation} with variable target" do
+      @expect_relation.call(type, @target, true)
+      @invoke_relation.call(relation, @target, true)
+    end
+  end
+
+  it 'should raise error if the target is of the wrong type' do
+    lambda do 
+      @invoke_relation.call(:==, 'hello', false)
+    end.should raise_error(TypeError) 
+  end
+end
+
+# Requires @invoke_options and @model.
+describe 'non-reifiable set constraint', :shared => true do
+  it 'should not accept strength option' do
+    lambda do 
+      @invoke_options.call(:strength => :default)
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should not accept reification option' do
+    bool = @model.bool_var
+    lambda do 
+      @invoke_options.call(:reify => bool)
+    end.should raise_error(ArgumentError)
+  end
+end
+
+# Requires @invoke_options, @expect_options and @model.
+describe 'reifiable set constraint', :shared => true do
+  it 'should not accept strength option' do
+    lambda do 
+      @invoke_options.call(:strength => :default)
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should accept reification option' do
+    bool = @model.bool_var
+    @expect_options.call(nil, bool)
+    @invoke_options.call(:reify => bool)
+  end
+end
+
+# Help methods for the GecodeR specs. 
+module GecodeR::Specs
+  module SetHelper
+    module_function
+  
+    # Returns the arguments that should be used in a partial mock to expect the
+    # specified constant set (possibly an array of arguments).
+    def expect_constant_set(constant_set)
+      if constant_set.kind_of? Range
+        return constant_set.first, constant_set.last
+      elsif constant_set.kind_of? Fixnum
+        constant_set
+      else
+        an_instance_of(Gecode::Raw::IntSet)
+      end
+    end
+  end
+end

data/specs/constraints/constraints.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Gecode::Constraints::Expression do
+  it 'should raise error if it doesn\'t get all parameters for initialization' do
+    lambda do 
+      Gecode::Constraints::Expression.new(Gecode::Model.new, :negate => false) 
+    end.should raise_error(ArgumentError)
+  end
+end
+
+describe Gecode::Constraints::IntEnum::Expression do
+  it 'should raise error unless lhs is an int enum' do
+    lambda do
+      Gecode::Constraints::IntEnum::Expression.new(Gecode::Model.new, 
+        :lhs => 'foo', :negate => false)
+    end.should raise_error(TypeError)
+  end
+end
+
+describe Gecode::Constraints::SetEnum::Expression do
+  it 'should raise error unless lhs is a set enum' do
+    lambda do
+      Gecode::Constraints::SetEnum::Expression.new(Gecode::Model.new, 
+        :lhs => 'foo', :negate => false)
+    end.should raise_error(TypeError)
+  end
+end
+
+describe Gecode::Constraints::Int::CompositeStub, ' (not subclassed)' do
+  before do
+    @con = Gecode::Constraints::Int::CompositeStub.new(Gecode::Model.new, {})
+  end
+
+  it 'should raise error when calling #constrain_equal' do
+    lambda do 
+      @con.instance_eval{ constrain_equal(nil, {}, false) }
+    end.should raise_error(NoMethodError)
+  end
+end
+
+describe Gecode::Constraints::Constraint, ' (not subclassed)' do
+  before do
+    @con = Gecode::Constraints::Constraint.new(Gecode::Model.new, {})
+  end
+
+  it 'should raise error when calling #post because it\'s not overridden' do
+    lambda{ @con.post }.should raise_error(NoMethodError)
+  end
+end
+
+describe Gecode::Constraints::Util do
+  it 'should raise error when giving incorrect set to #constant_set_to_params' do
+    lambda do 
+      Gecode::Constraints::Util.constant_set_to_params('hello')
+    end.should raise_error(TypeError)
+  end
+  
+  it 'should raise error when giving incorrect set to #constant_set_to_int_set' do
+    lambda do 
+      Gecode::Constraints::Util.constant_set_to_int_set('hello')
+    end.should raise_error(TypeError)
+  end
+end
+
+describe Gecode::Constraints::CompositeExpression do
+  it 'should raise error if a method doesn\'t exist' do
+    expression = Gecode::Constraints::CompositeExpression.new(
+      Gecode::Constraints::Int::Expression, Gecode::FreeIntVar, 
+      lambda{ }, Gecode::Model.new, {:lhs => nil, :negate => false}){}
+    lambda do
+      expression.this_method_does_not_exist
+    end.should raise_error(NoMethodError)
+  end
+end

data/specs/constraints/count.rb

@@ -0,0 +1,139 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
+
+class CountSampleProblem < Gecode::Model
+  attr :list
+  attr :element
+  attr :target
+  
+  def initialize
+    @list = int_var_array(4, 0..3)
+    @element = int_var(0..3)
+    @target = int_var(0..4)
+    branch_on @list
+  end
+end
+
+describe Gecode::Constraints::IntEnum::Count do
+  before do
+    @model = CountSampleProblem.new
+    @list = @model.list
+    @element = @model.element
+    @target = @model.target
+    
+    # Creates an expectation corresponding to the specified input.
+    @expect = lambda do |element, relation, target, strength, reif_var|
+      @model.allow_space_access do
+        target = an_instance_of(Gecode::Raw::IntVar) if target.respond_to? :bind
+        element = an_instance_of(Gecode::Raw::IntVar) if element.respond_to? :bind
+        if reif_var.nil?
+          Gecode::Raw.should_receive(:count).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::IntVarArray), 
+            element, relation, target, strength)
+        else
+          Gecode::Raw.should_receive(:count).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::IntVarArray), 
+            element, Gecode::Raw::IRT_EQ,
+            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,
+            target, an_instance_of(Gecode::Raw::BoolVar), strength)
+        end
+      end
+    end
+    
+    # For constraint option spec.
+    @invoke_options = lambda do |hash| 
+      @list.count(@element).must_be.greater_than(@target, hash) 
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      @expect.call(@element, Gecode::Raw::IRT_GR, @target, strength, reif_var)
+    end
+  end
+
+  # Various situations that must be handled (4*2 in total). This was originally
+  # written without the repetition (r269), but that interfered with the spec 
+  # somehow.
+
+  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
+    it "should translate #{relation} with variable element and target" do
+      @expect.call(@element, type, @target, Gecode::Raw::ICL_DEF, nil)
+      @list.count(@element).must.send(relation, @target)
+      @model.solve!
+    end
+  end
+  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate negated #{relation} with variable element and target" do
+      @expect.call(@element, type, @target, Gecode::Raw::ICL_DEF, nil)
+      @list.count(@element).must_not.send(relation, @target)
+      @model.solve!
+    end
+  end
+  
+  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
+    it "should translate #{relation} with variable element and constant target" do
+      @expect.call(@element, type, 2, Gecode::Raw::ICL_DEF, nil)
+      @list.count(@element).must.send(relation, 2)
+      @model.solve!
+    end
+  end
+  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate negated #{relation} with variable element and constant target" do
+      @expect.call(@element, type, 2, Gecode::Raw::ICL_DEF, nil)
+      @list.count(@element).must_not.send(relation, 2)
+      @model.solve!
+    end
+  end
+  
+  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
+    it "should translate #{relation} with constant element and constant target" do
+      @expect.call(1, type, 2, Gecode::Raw::ICL_DEF, nil)
+      @list.count(1).must.send(relation, 2)
+      @model.solve!
+    end
+  end
+  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate negated #{relation} with constant element and constant target" do
+      @expect.call(1, type, 2, Gecode::Raw::ICL_DEF, nil)
+      @list.count(1).must_not.send(relation, 2)
+      @model.solve!
+    end
+  end
+
+  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
+    it "should translate #{relation} with constant element and variable target" do
+      @expect.call(1, type, @target, Gecode::Raw::ICL_DEF, nil)
+      @list.count(1).must.send(relation, @target)
+      @model.solve!
+    end
+  end
+  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
+    it "should translate negated #{relation} with constant element and variable target" do
+      @expect.call(1, type, @target, Gecode::Raw::ICL_DEF, nil)
+      @list.count(1).must_not.send(relation, @target)
+      @model.solve!
+    end
+  end
+
+  it 'should raise error if the target is of the wrong type' do
+    lambda{ @list.count(@element).must == 'hello' }.should raise_error(
+      TypeError) 
+  end
+  
+  it 'should raise error on element is of the wrong type' do
+    lambda{ @list.count('foo').must == @target }.should raise_error(
+      TypeError)
+  end
+  
+  it 'should constrain the count' do
+    @list.must_be.distinct
+    @list.count(0).must <= 0
+    @model.solve!.should be_nil
+  end
+  
+  it_should_behave_like 'constraint with options'
+end

data/specs/constraints/distinct.rb

@@ -0,0 +1,218 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/constraint_helper'
+
+class DistinctSampleProblem < Gecode::Model
+  attr :vars
+  attr :sets
+  
+  def initialize
+    @vars = int_var_array(2, 1)
+    @sets = set_var_array(2, [], 0..2)
+    branch_on wrap_enum(@sets)
+  end
+end
+
+describe Gecode::Constraints::IntEnum::Distinct do
+  before do
+    @model = DistinctSampleProblem.new
+    @invoke_options = lambda do |hash| 
+      @model.vars.must_be.distinct(hash)
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      Gecode::Raw.should_receive(:distinct).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        an_instance_of(Gecode::Raw::IntVarArray), strength)
+    end
+  end
+
+  it 'should translate into a distinct constraint' do
+    Gecode::Raw.should_receive(:distinct).once.with(
+      an_instance_of(Gecode::Raw::Space), 
+      anything, Gecode::Raw::ICL_DEF)
+    @invoke_options.call({})
+  end
+
+  it 'should constrain variables to be distinct' do
+    # This won't work well without branching or propagation strengths. So this
+    # just shows that the distinct constraint will cause trivially unsolvable
+    # problems to directly fail.
+    @model.vars.must_be.distinct
+    @model.solve!.should be_nil
+  end
+
+  it 'should not allow negation' do
+    lambda{ @model.vars.must_not_be.distinct }.should raise_error(
+      Gecode::MissingConstraintError) 
+  end
+  
+  it_should_behave_like 'constraint with strength option'
+end
+
+describe Gecode::Constraints::IntEnum::Distinct, ' (with offsets)' do
+  before do
+    @model = DistinctSampleProblem.new
+    @invoke_options = lambda do |hash| 
+      @model.vars.with_offsets(1,2).must_be.distinct(hash)
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      if reif_var.nil?
+        Gecode::Raw.should_receive(:distinct).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          anything, an_instance_of(Gecode::Raw::IntVarArray), strength)
+      else
+        Gecode::Raw.should_receive(:distinct).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          anything, an_instance_of(Gecode::Raw::IntVarArray), strength,
+          an_instance_of(Gecode::Raw::BoolVar))
+      end
+    end
+  end
+
+  it 'should translate into a distinct constraint with offsets' do
+    Gecode::Raw.should_receive(:distinct).once.with(
+      an_instance_of(Gecode::Raw::Space), 
+      anything, anything, Gecode::Raw::ICL_DEF)
+    @invoke_options.call({})
+  end
+
+  it 'should consider offsets when making variables distinct' do
+    @model.vars.with_offsets(-1,0).must_be.distinct
+    x,y = @model.solve!.vars
+    x.value.should equal(1)
+    y.value.should equal(1)
+  end
+  
+  # This tests two distinct in conjunction. It's here because of a bug found.
+  it 'should play nice with normal distinct' do
+    @model.vars.with_offsets(-1,0).must_be.distinct
+    @model.vars.must_be.distinct
+    @model.solve!.should be_nil
+  end
+  
+  it 'should accept an array as offsets' do
+    @model.vars.with_offsets([-1,0]).must_be.distinct
+    x,y = @model.solve!.vars
+    x.value.should equal(1)
+    y.value.should equal(1)
+  end
+  
+  it 'should not allow negation' do
+    lambda{ @model.vars.with_offsets(1,2).must_not_be.distinct }.should 
+      raise_error(Gecode::MissingConstraintError)
+  end
+  
+  it_should_behave_like 'constraint with strength option'
+end
+
+describe Gecode::Constraints::SetEnum::Distinct do
+  before do
+    @model = DistinctSampleProblem.new
+    @sets = @model.sets
+    @size = 1
+    
+    @invoke_options = lambda do |hash| 
+      @sets.must_be.distinct(hash.update(:size => @size))
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      Gecode::Raw.should_receive(:distinct).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        an_instance_of(Gecode::Raw::SetVarArray), @size)
+    end
+  end
+
+  it 'should translate into a distinct constraint' do
+    Gecode::Raw.should_receive(:distinct).once.with(
+      an_instance_of(Gecode::Raw::Space), 
+      an_instance_of(Gecode::Raw::SetVarArray), @size)
+    @sets.must_be.distinct(:size => @size)
+    @model.solve!
+  end
+
+  it 'should constrain sets to be distinct' do
+    @sets.must_be.distinct(:size => @size)
+    @sets[0].must_be.superset_of 0
+    solution = @model.solve!
+    solution.should_not be_nil
+    set1, set2 = solution.sets
+    set1.value.size.should == @size
+    set2.value.size.should == @size
+    set1.value.should_not == set2.value
+  end
+  
+  it 'should not allow negation' do
+    lambda{ @sets.must_not_be.distinct(:size => @size) }.should raise_error(
+      Gecode::MissingConstraintError)
+  end
+  
+  it 'should not allow options other than :size' do
+    lambda do
+      @sets.must_be.distinct(:size => @size, :foo => 17)
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should raise error if :size is not specified' do
+    lambda{ @sets.must_be.distinct }.should raise_error(ArgumentError)
+  end
+  
+  it_should_behave_like 'non-reifiable set constraint'
+end
+
+describe Gecode::Constraints::SetEnum::Distinct, ' (at most one)' do
+  before do
+    @model = DistinctSampleProblem.new
+    @sets = @model.sets
+    @size = 2
+    
+    @invoke_options = lambda do |hash| 
+      @sets.must.at_most_share_one_element hash.update(:size => @size)
+      @model.solve!
+    end
+    @expect_options = lambda do |strength, reif_var|
+      Gecode::Raw.should_receive(:atmostOne).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        an_instance_of(Gecode::Raw::SetVarArray), @size)
+    end
+  end
+
+  it 'should translate into a atmostOne constraint' do
+    Gecode::Raw.should_receive(:atmostOne).once.with(
+      an_instance_of(Gecode::Raw::Space), 
+      an_instance_of(Gecode::Raw::SetVarArray), @size)
+    @sets.must.at_most_share_one_element(:size => @size)
+    @model.solve!
+  end
+
+  it 'should constrain sets to have at most one element in common' do
+    @sets.must.at_most_share_one_element(:size => @size)
+    @sets[0].must_not_be.superset_of 0
+    solution = @model.solve!
+    solution.should_not be_nil
+    set1, set2 = solution.sets
+    set1.value.size.should == @size
+    set2.value.size.should == @size
+    (set1.value.to_a & set2.value.to_a).size.should <= 1
+  end
+
+  it 'should not allow negation' do
+    lambda do
+      @sets.must_not.at_most_share_one_element(:size => @size) 
+    end.should raise_error(Gecode::MissingConstraintError)
+  end
+  
+  it 'should not allow options other than :size' do
+    lambda do
+      @sets.must.at_most_share_one_element(:size => @size, :foo => 17) 
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should raise error if :size is not specified' do
+    lambda do
+      @sets.must.at_most_share_one_element 
+    end.should raise_error(ArgumentError)
+  end
+  
+  it_should_behave_like 'non-reifiable set constraint'
+end