gecoder 0.8.3 → 0.9.0

data/specs/constraints/distinct.rb

@@ -1,164 +0,0 @@
-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 @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 = option_expectation do |strength, kind, reif_var|
-      Gecode::Raw.should_receive(:distinct).once.with(
-        an_instance_of(Gecode::Raw::Space), 
-        an_instance_of(Gecode::Raw::IntVarArray), strength, kind)
-    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, Gecode::Raw::PK_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 'non-reifiable constraint'
-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 = option_expectation do |strength, kind, 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, kind)
-      else
-        Gecode::Raw.should_receive(:distinct).once.with(
-          an_instance_of(Gecode::Raw::Space), 
-          anything, an_instance_of(Gecode::Raw::IntVarArray), 
-          strength, kind, reif_var)
-      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, Gecode::Raw::PK_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 'non-reifiable 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

data/specs/constraints/element.rb

@@ -1,108 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/constraint_helper'
-
-class ElementSampleProblem < Gecode::Model
-  attr :prices
-  attr :store
-  attr :price
-  attr :fixnum_prices
-  
-  def initialize
-    prices = [17, 63, 45, 63]
-    @fixnum_prices = wrap_enum(prices)
-    @prices = int_var_array(4, prices)
-    @store = int_var(0...prices.size)
-    @price = int_var(prices)
-    branch_on wrap_enum([@store])
-  end
-end
-
-describe Gecode::Constraints::IntEnum::Element do
-  before do
-    @model = ElementSampleProblem.new
-    @prices = @model.prices
-    @target = @price = @model.price
-    @store = @model.store
-    @fixnum_prices = @model.fixnum_prices
-    
-    # Creates an expectation corresponding to the specified input.
-    @expect = lambda do |element, relation, target, strength, kind, reif_var, negated|
-      @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?
-          if !negated and relation == Gecode::Raw::IRT_EQ and 
-              !target.kind_of? Fixnum
-            Gecode::Raw.should_receive(:element).once.with( 
-              an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVarArray), 
-              element, target, strength, kind)
-          else
-            Gecode::Raw.should_receive(:element).once.with(
-              an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::IntVarArray), 
-              element, 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, target, strength, kind)
-          end
-        else
-          Gecode::Raw.should_receive(:element).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVarArray), 
-            element, 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, target, 
-            an_instance_of(Gecode::Raw::BoolVar), strength, kind)
-        end
-      end
-    end
-
-    # For constraint option spec.
-    @invoke_options = lambda do |hash| 
-      @prices[@store].must_be.greater_than(@price, hash) 
-      @model.solve!
-    end
-    @expect_options = option_expectation do |strength, kind, reif_var|
-      @expect.call(@store, Gecode::Raw::IRT_GR, @price, strength, kind, 
-        reif_var, false)
-    end
-    
-    # For composite spec.
-    @invoke_relation = lambda do |relation, target, negated|
-      if negated
-        @prices[@store].must_not.send(relation, target)
-      else
-        @prices[@store].must.send(relation, target)
-      end
-      @model.solve!
-    end
-    @expect_relation = lambda do |relation, target, negated|
-      @expect.call(@store, relation, target, Gecode::Raw::ICL_DEF, 
-        Gecode::Raw::PK_DEF, nil, negated)
-    end
-  end
-
-  it 'should not disturb normal array access' do
-    @fixnum_prices[2].should_not be_nil
-    @prices[2].should_not be_nil
-  end
-
-  it 'should handle fixnum enums as enumeration' do
-    @fixnum_prices[@store].must == @fixnum_prices[2]
-    @model.solve!.store.value.should equal(2)
-  end
-  
-  it 'should translate reification when using equality' do
-    bool_var = @model.bool_var
-    @expect.call(@store, Gecode::Raw::IRT_EQ, @target, Gecode::Raw::ICL_DEF, 
-      Gecode::Raw::PK_DEF, bool_var, false)
-    @prices[@store].must_be.equal_to(@target, :reify => bool_var)
-    @model.solve!
-  end
-  
-  it_should_behave_like 'composite constraint'
-  it_should_behave_like 'reifiable constraint'
-end

data/specs/constraints/equality.rb

@@ -1,31 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/constraint_helper'
-
-describe Gecode::Constraints::IntEnum::Equality do
-  before do
-    @model = Gecode::Model.new
-    @vars = @model.int_var_array(4, -2..2)
-    @invoke_options = lambda do |hash| 
-      @vars.must_be.equal(hash)
-      @model.solve!
-    end
-    @expect_options = option_expectation do |strength, kind, reif_var|
-      Gecode::Raw.should_receive(:eq).once.with(
-        an_instance_of(Gecode::Raw::Space), 
-        anything, strength, kind)
-    end
-  end
-  
-  it 'should translate equality constraints' do
-    @expect_options.call({})
-    @invoke_options.call({})
-    @vars.must_be.equal
-  end
-
-  it 'should not allow negation' do
-    lambda{ @vars.must_not_be.equal }.should raise_error(
-      Gecode::MissingConstraintError)
-  end
-  
-  it_should_behave_like 'non-reifiable constraint'
-end

data/specs/constraints/int_domain.rb

@@ -1,70 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/constraint_helper'
-
-describe Gecode::Constraints::Int::Domain do
-  before do
-    @model = Gecode::Model.new
-    @domain = 0..3
-    @x = @model.int_var(@domain)
-    @range_domain = 1..2
-    @three_dot_range_domain = 1...2
-    @non_range_domain = [1, 3]
-    
-    @invoke_options = lambda do |hash| 
-      @x.must_be.in(@non_range_domain, hash) 
-      @model.solve!
-    end
-    @expect_options = option_expectation do |strength, kind, reif_var|
-      @model.allow_space_access do
-        if reif_var.nil?
-          Gecode::Raw.should_receive(:dom).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVar), 
-            an_instance_of(Gecode::Raw::IntSet), 
-            strength, kind)
-        else
-          Gecode::Raw.should_receive(:dom).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::IntVar), 
-            an_instance_of(Gecode::Raw::IntSet), 
-            reif_var, strength, kind)
-        end
-      end
-    end
-  end
-  
-  it 'should translate domain constraints with range domains' do
-    Gecode::Raw.should_receive(:dom).once.with(
-      an_instance_of(Gecode::Raw::Space), 
-      an_instance_of(Gecode::Raw::IntVar), @range_domain.first, 
-      @range_domain.last, Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF)
-    @x.must_be.in @range_domain
-    @model.solve!
-  end
-
-  it 'should translate domain constraints with three dot range domains' do
-    Gecode::Raw.should_receive(:dom).once.with(
-      an_instance_of(Gecode::Raw::Space), 
-      an_instance_of(Gecode::Raw::IntVar), @three_dot_range_domain.first, 
-      @three_dot_range_domain.last, Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF)
-    @x.must_be.in @three_dot_range_domain
-    @model.solve!
-  end
-  
-  it 'should translate domain constraints with non-range domains' do
-    @expect_options.call({})
-    @invoke_options.call({})
-  end
-  
-  it 'should handle negation' do
-    @x.must_not_be.in @range_domain
-    @model.solve!
-    @x.should have_domain(@domain.to_a - @range_domain.to_a)
-  end
-  
-  it 'should raise error if the right hand side is not an enumeration' do
-    lambda{ @x.must_be.in 'hello' }.should raise_error(TypeError)
-  end
-  
-  it_should_behave_like 'reifiable constraint'
-end

data/specs/constraints/int_relation.rb

@@ -1,82 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/constraint_helper'
-
-describe Gecode::Constraints::Int::Linear, ' (simple ones)' do
-  before do
-    @model = Gecode::Model.new
-    @x = @model.int_var(1..2)
-    @int = 4
-    @y = @model.int_var(1..2)
-    
-    # For constraint option spec.
-    @invoke_options = lambda do |hash| 
-      @x.must_be.greater_than(3, hash) 
-      @model.solve!
-    end
-    @expect_options = option_expectation do |strength, kind, reif_var|
-      if reif_var.nil?
-        Gecode::Raw.should_receive(:rel).once.with(
-          an_instance_of(Gecode::Raw::Space), 
-          anything, Gecode::Raw::IRT_GR, anything, 
-          strength, kind)
-      else
-        Gecode::Raw.should_receive(:rel).once.with(
-          an_instance_of(Gecode::Raw::Space), 
-          an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_GR, anything, 
-          reif_var, strength, kind)
-      end
-    end
-  end
-  
-  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
-    it "should translate #{relation} with constant to simple relation" do
-      Gecode::Raw.should_receive(:rel).once.with(
-        an_instance_of(Gecode::Raw::Space), 
-        an_instance_of(Gecode::Raw::IntVar), 
-        type, @int, Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF)
-      @x.must.send(relation, @int)
-      @model.solve!
-    end
-  end
-
-  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
-    it "should translate negated #{relation} with constant to simple relation" do
-      Gecode::Raw.should_receive(:rel).once.with(
-        an_instance_of(Gecode::Raw::Space), 
-        an_instance_of(Gecode::Raw::IntVar), 
-        type, @int, Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF)
-      @x.must_not.send(relation, @int)
-      @model.solve!
-    end
-  end
-
-  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
-    it "should translate #{relation} with variables to simple relation" do
-      Gecode::Raw.should_receive(:rel).once.with(
-        an_instance_of(Gecode::Raw::Space), 
-        an_instance_of(Gecode::Raw::IntVar), type, 
-        an_instance_of(Gecode::Raw::IntVar), 
-        Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF)
-      @x.must.send(relation, @y)
-      @model.solve!
-    end
-  end
-
-  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
-    it "should translate negated #{relation} with variable to simple relation" do
-      Gecode::Raw.should_receive(:rel).once.with(
-        an_instance_of(Gecode::Raw::Space), 
-        an_instance_of(Gecode::Raw::IntVar), type, 
-        an_instance_of(Gecode::Raw::IntVar), 
-        Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF)
-      @x.must_not.send(relation, @y)
-      @model.solve!
-    end
-  end
-
-  it 'should raise error on arguments of the wrong type' do
-    lambda{ @x.must == 'hello' }.should raise_error(TypeError) 
-  end
-  
-  it_should_behave_like 'reifiable constraint'
-end