gecoder 0.8.3 → 0.9.0

data/specs/constraints/set_relation.rb

@@ -1,197 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/constraint_helper'
-
-describe Gecode::Constraints::Set::Relation do
-  include GecodeR::Specs::SetHelper
-
-  before do
-    @model = Gecode::Model.new
-    @set = @model.set_var([0], 0..3)
-    @set2 = @model.set_var([1], 0..3)
-    
-    @expect = lambda do |relation_type, rhs, reif_var, negated|
-      @model.allow_space_access do
-        if reif_var.nil? and !negated
-          Gecode::Raw.should_receive(:rel).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::SetVar), relation_type, 
-            an_instance_of(Gecode::Raw::SetVar))
-        else
-          Gecode::Raw.should_receive(:rel).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::SetVar), relation_type, 
-            an_instance_of(Gecode::Raw::SetVar), 
-            an_instance_of(Gecode::Raw::BoolVar))
-        end
-      end
-    end
-    
-    # For options spec.
-    @invoke_options = lambda do |hash| 
-      @set.must_be.superset_of(@set2, hash)
-      @model.solve!
-    end
-    @expect_options = option_expectation do |strength, kind, reif_var|
-      @expect.call(Gecode::Raw::SRT_SUP, @set2, reif_var, false)
-    end
-  end
-
-  Gecode::Constraints::Util::SET_RELATION_TYPES.each_pair do |relation, type|
-    next if relation == :==
-  
-    it "should translate #{relation} with set to relation constraint" do
-      @expect.call(type, @set2, nil, false)
-      @set.must.send(relation, @set2)
-      @model.solve!
-    end
-  
-    it "should translate negated #{relation} with set to relation constraint" do
-      @expect.call(type, @set2, nil, true)
-      @set.must_not.send(relation, @set2)
-      @model.solve!
-    end
-  end
-  it_should_behave_like 'reifiable set constraint'
-end
-
-describe Gecode::Constraints::Set::Relation, ' (equality)' do
-  include GecodeR::Specs::SetHelper
-
-  before do
-    @model = Gecode::Model.new
-    @set = @model.set_var([0], 0..1)
-    @set2 = @model.set_var([1], 0..1)
-    
-    @expect = lambda do |relation_type, rhs, reif_var|
-      @model.allow_space_access do
-        if reif_var.nil?
-          Gecode::Raw.should_receive(:rel).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::SetVar), relation_type, 
-            an_instance_of(Gecode::Raw::SetVar))
-        else
-          Gecode::Raw.should_receive(:rel).once.with(
-            an_instance_of(Gecode::Raw::Space), 
-            an_instance_of(Gecode::Raw::SetVar), relation_type, 
-            an_instance_of(Gecode::Raw::SetVar), 
-            an_instance_of(Gecode::Raw::BoolVar))
-        end
-      end
-    end
-    
-    # For options spec.
-    @invoke_options = lambda do |hash| 
-      @set.must_be.equal_to(@set2, hash)
-      @model.solve!
-    end
-    @expect_options = option_expectation do |strength, kind, reif_var|
-      @expect.call(Gecode::Raw::SRT_EQ, @set2, reif_var)
-    end
-  end
-  
-  it 'should translate equality with set to relation constraint' do
-    @expect.call(Gecode::Raw::SRT_EQ, @set2, nil)
-    @set.must == @set2
-    @model.solve!
-  end
-  
-  it 'should translate negated equality with set to domain constraint' do
-    @expect.call(Gecode::Raw::SRT_NQ, @set2, nil)
-    @set.must_not == @set2
-    @model.solve!
-  end
-  
-  it 'should constrain sets to be equality when not negated' do
-    @set.must == @set2
-    @model.solve!
-    @set.should have_bounds(0..1, 0..1)
-    @set2.should have_bounds(0..1, 0..1)
-  end
-  
-  it 'should constrain sets to not be equal when negated' do
-    @set.must_not == @set2
-    union = @model.set_var([0, 1], [0, 1])
-    @set.must_not == union
-    @set2.must_not == union
-    @model.solve!
-    @set.should have_bounds([0], [0])
-    @set2.should have_bounds([1], [1])
-  end
-  
-  it_should_behave_like 'reifiable set constraint'
-end
-
-describe Gecode::Constraints::Set::Relation, ' (elements)' do
-  include GecodeR::Specs::SetHelper
-
-  before do
-    @model = Gecode::Model.new
-    @set = @model.set_var([0], 0..2)
-    @int_var = @model.int_var(0..2)
-    @int_constant = 2
-    @model.branch_on @model.wrap_enum([@set])
-    @expect = lambda do |relation_type, rhs|
-      @model.allow_space_access do
-        if rhs.kind_of? Fixnum
-          rhs = an_instance_of(Gecode::Raw::IntVar)
-        end
-        rhs = rhs.bind if rhs.respond_to? :bind
-        Gecode::Raw.should_receive(:rel).once.with(
-          an_instance_of(Gecode::Raw::Space), 
-          an_instance_of(Gecode::Raw::SetVar), relation_type, 
-          an_instance_of(Gecode::Raw::IntVar))
-      end
-    end
-    
-    @invoke_options = lambda do |hash|
-      @set.elements.must_be.equal_to(@int_var, hash)
-    end
-  end
-  
-  Gecode::Constraints::Util::RELATION_TYPES.each_pair do |relation, type|
-    it "should translate #{relation} with variable to relation constraint" do
-      @expect.call(type, @int_var)
-      @set.elements.must.send(relation, @int_var)
-      @model.solve!
-    end
-    
-    it "should translate #{relation} with constant to relation constraint" do
-      @expect.call(type, @int_constant)
-      @set.elements.must.send(relation, @int_constant)
-      @model.solve!
-    end
-  end
-
-  Gecode::Constraints::Util::NEGATED_RELATION_TYPES.each_pair do |relation, type|
-    it "should translate negated #{relation} with variable to relation constraint" do
-      @expect.call(type, @int_var)
-      @set.elements.must_not.send(relation, @int_var)
-      @model.solve!
-    end
-    
-    it "should translate negated #{relation} with constant to relation constraint" do
-      @expect.call(type, @int_constant)
-      @set.elements.must_not.send(relation, @int_constant)
-      @model.solve!
-    end
-  end
-  
-  it 'should constrain the elements of the set' do
-    @set.elements.must <= @int_var
-    @int_var.must == 0
-    @model.solve!
-    @set.should be_assigned
-    @set.value.should include(0)
-    @set.value.should_not include(1,2)
-  end
-  
-  it 'should constrain the elements of the set (constant parameter)' do
-    @set.elements.must <= 0
-    @model.solve!
-    @set.should be_assigned
-    @set.value.should include(0)
-    @set.value.should_not include(1,2)
-  end
-  
-  it_should_behave_like 'non-reifiable set constraint'
-end

data/specs/constraints/sort.rb

@@ -1,179 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-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::Constraints::IntEnum::Sort, ' (without :as and :order)' do
-  before do
-    @model = SortSampleProblem.new
-    @vars = @model.vars
-    @sorted = @model.sorted
-    
-    @invoke_options = lambda do |hash| 
-      @vars.must_be.sorted(hash)
-      @model.solve!
-    end
-    @expect_options = option_expectation do |strength, kind, reif_var|
-      if reif_var.nil?
-        Gecode::Raw.should_receive(:rel).exactly(@vars.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), strength, kind)
-      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(@vars.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), strength, kind)
-      end
-    end
-  end
-  
-  it 'should translate into n relation constraints' do
-    @expect_options.call({})
-    @invoke_options.call({})
-  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::Constraints::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
-    
-    @invoke_options = lambda do |hash| 
-      @vars.must_be.sorted hash.update(:as => @sorted) 
-      @model.solve!
-    end
-    @expect_options = option_expectation do |strength, kind, reif_var|
-      Gecode::Raw.should_receive(:sorted).once.with(
-        an_instance_of(Gecode::Raw::Space), 
-        an_instance_of(Gecode::Raw::IntVarArray), 
-        an_instance_of(Gecode::Raw::IntVarArray), strength, kind)
-    end
-  end
-  
-  it 'should translate into a sortedness constraints' do
-    @expect_options.call({})
-    @invoke_options.call({})
-  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 not allow targets that are not int var enums' do
-    lambda{ @vars.must_be.sorted(:as => 'hello') }.should raise_error(TypeError) 
-  end
-  
-  it 'should not allow negation' do
-    lambda{ @vars.must_not_be.sorted(:as => @sorted) }.should raise_error(
-      Gecode::MissingConstraintError) 
-  end
-  
-  it_should_behave_like 'non-reifiable constraint'
-end
-
-describe Gecode::Constraints::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
-    
-    @invoke_options = lambda do |hash| 
-      @vars.must_be.sorted hash.update(:order => @indices, :as => @sorted) 
-      @model.solve!
-    end
-    @expect_options = option_expectation do |strength, kind, reif_var|
-      Gecode::Raw.should_receive(:sorted).once.with(
-        an_instance_of(Gecode::Raw::Space), 
-        an_instance_of(Gecode::Raw::IntVarArray), 
-        an_instance_of(Gecode::Raw::IntVarArray),
-        an_instance_of(Gecode::Raw::IntVarArray), strength, kind)
-    end
-  end
-  
-  it 'should translate into a sortedness constraints' do
-    @expect_options.call({})
-    @invoke_options.call({})
-  end
-  
-  it 'should translate into a sortedness constraints, even without a target' do
-    @expect_options.call({})
-    @vars.must_be.sorted(:order => @indices) 
-    @model.solve!
-  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 not allow targets that are not int var enums' do
-    lambda do
-      @vars.must_be.sorted(:as => 'hello', :order => @indices)
-    end.should raise_error(TypeError) 
-  end
-  
-  it 'should not allow order that are not int var enums' do
-    lambda do
-      @vars.must_be.sorted(:as => @sorted, :order => 'hello')
-    end.should raise_error(TypeError) 
-  end
-  
-  it 'should not allow negation' do
-    lambda do
-      @vars.must_not_be.sorted(:as => @sorted, :order => @indices)
-    end.should raise_error(Gecode::MissingConstraintError) 
-  end
-  
-  it_should_behave_like 'non-reifiable constraint'
-end