gecoder 0.8.3 → 0.9.0

data/specs/constraints/linear.rb

@@ -1,340 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/constraint_helper'
-
-class LinearSampleProblem < Gecode::Model
-  attr :x
-  attr :y
-  attr :z
-  
-  def initialize(x_dom, y_dom, z_dom)
-    @x = self.int_var(x_dom)
-    @y = self.int_var(y_dom)
-    @z = self.int_var(z_dom)
-    branch_on wrap_enum([@x, @y, @z])
-  end
-end
-
-class BoolLinearSampleProblem < Gecode::Model
-  attr :x
-  attr :y
-  attr :z
-  
-  def initialize
-    @x = self.bool_var
-    @y = self.bool_var
-    @z = self.bool_var
-    branch_on wrap_enum([@x, @y, @z])
-  end
-end
-
-class TrueClass
-  def to_i
-    1
-  end
-end
-
-class FalseClass
-  def to_i
-    0
-  end
-end
-
-describe Gecode::Constraints::Int::Linear do
-  before do
-    @x_dom = 0..2
-    @y_dom = -3..3
-    @z_dom = 0..10
-    @model = LinearSampleProblem.new(@x_dom, @y_dom, @z_dom)
-    @x = @model.x
-    @y = @model.y
-    @z = @model.z
-    
-    # For constraint option spec.
-    @invoke_options = lambda do |hash| 
-      (@x + @y).must_be.greater_than(@z, hash)
-      @model.solve!
-    end
-    @expect_options = option_expectation do |strength, kind, reif_var|
-      # TODO: this is hard to spec from this level.
-    end
-  end
-
-  it 'should handle addition with a variable' do
-    (@x + @y).must == 0
-    sol = @model.solve!
-    x = sol.x.value
-    y = sol.y.value
-    (x + y).should be_zero
-  end
-  
-  it 'should handle addition with multiple variables' do
-    (@x + @y + @z).must == 0
-    sol = @model.solve!
-    x = sol.x.value
-    y = sol.y.value
-    z = sol.z.value
-    (x + y + z).should be_zero
-  end
-  
-  it 'should handle subtraction with a variable' do
-    (@x - @y).must == 0
-    sol = @model.solve!
-    x = sol.x.value
-    y = sol.y.value
-    (x - y).should be_zero
-  end
-  
-  it 'should handle non-zero constants as right hand side' do
-    (@x + @y).must == 1
-    sol = @model.solve!
-    x = sol.x.value
-    y = sol.y.value
-    (x + y).should equal(1)
-  end
-  
-  it 'should handle variables as right hand side' do
-    (@x + @y).must == @z
-    sol = @model.solve!
-    x = sol.x.value
-    y = sol.y.value
-    z = sol.z.value
-    (x + y).should equal(z)
-  end
-  
-  it 'should handle linear expressions as right hand side' do
-    (@x + @y).must == @z + @y
-    sol = @model.solve!
-    x = sol.x.value
-    y = sol.y.value
-    z = sol.z.value
-    (x + y).should equal(z + y)
-  end
-  
-  it 'should raise error on invalid right hand sides' do
-    lambda{ ((@x + @y).must == 'z') }.should raise_error(TypeError) 
-  end
-  
-  it 'should handle coefficients other than 1' do
-    (@x * 2 + @y).must == 0
-    sol = @model.solve!
-    x = sol.x.value
-    y = sol.y.value
-    (2*x + y).should equal(0)
-  end
-  
-  it 'should handle addition with constants' do
-    (@y + 2).must == 1
-    sol = @model.solve!
-    y = sol.y.value
-    (y + 2).should equal(1)
-  end
-  
-  it 'should handle subtraction with a constant' do
-    (@x - 2).must == 0
-    sol = @model.solve!
-    x = sol.x.value
-    (x - 2).should be_zero
-  end
-  
-  it 'should a single variable as left hande side' do
-    @x.must == @y + @z
-    sol = @model.solve!
-    x = sol.x.value
-    y = sol.y.value
-    z = sol.z.value
-    x.should equal(y + z)
-  end
-  
-  it 'should handle parenthesis' do
-    (@x - (@y + @z)).must == 1
-    sol = @model.solve!
-    x = sol.x.value
-    y = sol.y.value
-    z = sol.z.value
-    (x - (y + z)).should equal(1)
-  end
-  
-  it 'should handle multiplication of parenthesis' do
-    (((@x + @y*10)*10 + @z)*10).must == 0
-    sol = @model.solve!
-    x = sol.x.value
-    y = sol.y.value
-    z = sol.z.value
-    (((x + y*10)*10 + z)*10).should equal(0)
-  end
-  
-  relations = ['>', '>=', '<', '<=', '==']
-  
-  relations.each do |relation|
-    it "should handle #{relation} with constant integers" do
-      (@x + @y).must.send(relation, 1)
-      sol = @model.solve!
-      sol.should_not be_nil
-      (sol.x.value + sol.y.value).should.send(relation, 1)
-    end
-  end
-  
-  relations.each do |relation|
-    it "should handle negated #{relation} with constant integers" do
-      (@x + @y).must_not.send(relation, 1)
-      sol = @model.solve!
-      sol.should_not be_nil
-      (sol.x.value + sol.y.value).should_not.send(relation, 1)
-    end
-  end
-  
-  it 'should not interfere with other defined multiplication methods' do
-    (@x * :foo).should be_nil
-  end
-  
-  it_should_behave_like 'reifiable constraint'
-end
-
-describe Gecode::Constraints::Int::Linear, '(with booleans)' do
-  before do
-    @model = BoolLinearSampleProblem.new
-    @x = @model.x
-    @y = @model.y
-    @z = @model.z
-    
-    # For constraint option spec.
-    @invoke_options = lambda do |hash| 
-      (@x + @y).must_be.greater_than(@z, hash)
-      @model.solve!
-    end
-    @expect_options = option_expectation do |strength, kind, reif_var|
-      # TODO: this is hard to spec from this level.
-    end
-  end
-
-  it 'should handle addition with a variable' do
-    (@x + @y).must == 0
-    sol = @model.solve!
-    x = sol.x.value.to_i
-    y = sol.y.value.to_i
-    (x + y).should be_zero
-  end
-  
-  it 'should handle addition with multiple variables' do
-    (@x + @y + @z).must == 0
-    sol = @model.solve!
-    x = sol.x.value.to_i
-    y = sol.y.value.to_i
-    z = sol.z.value.to_i
-    (x + y + z).should be_zero
-  end
-  
-  it 'should handle subtraction with a variable' do
-    (@x - @y).must == 0
-    sol = @model.solve!
-    x = sol.x.value.to_i
-    y = sol.y.value.to_i
-    (x - y).should be_zero
-  end
-  
-  it 'should handle non-zero constants as right hand side' do
-    (@x + @y).must == 1
-    sol = @model.solve!
-    x = sol.x.value.to_i
-    y = sol.y.value.to_i
-    (x + y).should equal(1)
-  end
-  
-  it 'should handle singe booleans as left hand side' do
-    @x.must == @y + 1 
-    sol = @model.solve!
-    x = sol.x.value.to_i
-    y = sol.y.value.to_i
-    x.should equal(y + 1)
-  end
-  
-  it 'should handle variables as right hand side' do
-    (@x + @y).must == @z
-    sol = @model.solve!
-    x = sol.x.value.to_i
-    y = sol.y.value.to_i
-    z = sol.z.value.to_i
-    (x + y).should equal(z)
-  end
-  
-  it 'should handle linear expressions as right hand side' do
-    (@x + @y).must == @z + @y
-    sol = @model.solve!
-    x = sol.x.value.to_i
-    y = sol.y.value.to_i
-    z = sol.z.value.to_i
-    (x + y).should equal(z + y)
-  end
-  
-  it 'should raise error on invalid right hand sides' do
-    lambda{ ((@x + @y).must == 'z') }.should raise_error(TypeError) 
-  end
-  
-  it 'should handle coefficients other than 1' do
-    (@x * 2 + @y).must == 0
-    sol = @model.solve!
-    x = sol.x.value.to_i
-    y = sol.y.value.to_i
-    (2*x + y).should equal(0)
-  end
-  
-  it 'should handle addition with constants' do
-    (@y + 1).must == 1
-    sol = @model.solve!
-    y = sol.y.value.to_i
-    (y + 1).should equal(1)
-  end
-  
-  it 'should handle subtraction with a constant' do
-    (@x - 1).must == 0
-    sol = @model.solve!
-    x = sol.x.value.to_i
-    (x - 1).should be_zero
-  end
-
-  it 'should handle parenthesis' do
-    (@x - (@y + @z)).must == 1
-    sol = @model.solve!
-    x = sol.x.value.to_i
-    y = sol.y.value.to_i
-    z = sol.z.value.to_i
-    (x - (y + z)).should equal(1)
-  end
-  
-  it 'should handle multiplication of parenthesis' do
-    (((@x + @y*10)*10 + @z)*10).must == 0
-    sol = @model.solve!
-    x = sol.x.value.to_i
-    y = sol.y.value.to_i
-    z = sol.z.value.to_i
-    (((x + y*10)*10 + z)*10).should equal(0)
-  end
-  
-  relations = ['>', '>=', '<', '<=', '==']
-  
-  relations.each do |relation|
-    it "should handle #{relation} with constant integers" do
-      (@x + @y).must.send(relation, 1)
-      sol = @model.solve!
-      sol.should_not be_nil
-      (sol.x.value.to_i + sol.y.value.to_i).should.send(relation, 1)
-    end
-  end
-  
-  relations.each do |relation|
-    it "should handle negated #{relation} with constant integers" do
-      (@x + @y).must_not.send(relation, 1)
-      sol = @model.solve!
-      sol.should_not be_nil
-      (sol.x.value.to_i + sol.y.value.to_i).should_not.send(relation, 1)
-    end
-  end
-  
-  it 'should not interfere with other defined multiplication methods' do
-    (@x * :foo).should be_nil
-  end
-  
-  it_should_behave_like 'reifiable constraint'
-end
-
-

data/specs/constraints/selection.rb

@@ -1,292 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/constraint_helper'
-
-class SelectionSampleProblem < Gecode::Model
-  attr :sets
-  attr :set
-  attr :target
-  attr :index
-  
-  def initialize
-    @sets = set_var_array(3, [], 0..20)
-    @set = set_var([], 0...3)
-    @target = set_var([], 0..20)
-    @index = int_var(0...3)
-    branch_on wrap_enum([@index])
-    branch_on @sets
-  end
-end
-
-# Requires everything that composite behaviour spec requires in addition to
-# @stub and @expect_constrain_equal .
-describe 'selection constraint', :shared => true do
-  before do
-    @expect = lambda do |index, relation, target, reif_var, negated|
-      @model.allow_space_access do
-        if target.respond_to? :bind
-          expected_target = [an_instance_of(Gecode::Raw::SetVar)]
-          relation_constraint = :rel
-        else
-          expected_target = expect_constant_set(target)
-          relation_constraint = :dom
-        end
-        if reif_var.nil?
-          if !negated and relation == Gecode::Raw::IRT_EQ and 
-              !target.kind_of? Enumerable
-            @expect_constrain_equal.call
-            Gecode::Raw.should_receive(:rel).exactly(0).times
-            Gecode::Raw.should_receive(:dom).exactly(0).times
-          else
-            @expect_constrain_equal.call
-            if relation_constraint == :dom
-              # We can't seem to get any more specific than this with mocks. 
-              Gecode::Raw.should_receive(relation_constraint).at_most(:twice)
-            else
-              Gecode::Raw.should_receive(relation_constraint).once.with(
-                an_instance_of(Gecode::Raw::Space), 
-                an_instance_of(Gecode::Raw::SetVar), relation, *expected_target)
-            end
-          end
-        else
-          @expect_constrain_equal.call
-          if relation_constraint == :dom
-            Gecode::Raw.should_receive(relation_constraint).at_least(:twice)
-          else
-            expected_target << an_instance_of(Gecode::Raw::BoolVar)
-            Gecode::Raw.should_receive(relation_constraint).once.with(
-              an_instance_of(Gecode::Raw::Space), 
-              an_instance_of(Gecode::Raw::SetVar), relation, *expected_target)
-          end
-        end
-      end
-    end
-    
-    # For composite spec.
-    @invoke_relation = lambda do |relation, target, negated|
-      if negated
-        @stub.must_not.send(relation, target)
-      else
-        @stub.must.send(relation, target)
-      end
-      @model.solve!
-    end
-    @expect_relation = lambda do |relation, target, negated|
-      @expect.call(@index, relation, target, nil, negated)
-    end
-    
-    # For options spec.
-    @invoke_options = lambda do |hash|
-      @stub.must_be.subset_of(@target, hash)
-      @model.solve!
-    end
-    @expect_options = option_expectation do |strength, kind, reif_var|
-      @expect.call(17, Gecode::Raw::SRT_SUB, @target, reif_var, false)
-    end
-  end
-  
-  it 'should not disturb normal array access' do
-    @sets[0].should be_kind_of(Gecode::FreeSetVar)
-  end
-  
-  it_should_behave_like 'reifiable set constraint'
-  it_should_behave_like 'composite set constraint'
-end
-
-describe Gecode::Constraints::SetEnum::Selection, ' (select)' do
-  include GecodeR::Specs::SetHelper
-
-  before do
-    @model = SelectionSampleProblem.new
-    @sets = @model.sets
-    @target = @set = @model.target
-    @index = @model.index
-    @model.branch_on @model.wrap_enum([@set])
-    @stub = @sets[@index]
-    
-    @expect_constrain_equal = lambda do
-      Gecode::Raw.should_receive(:selectSet).once.with( 
-        an_instance_of(Gecode::Raw::Space),
-        an_instance_of(Gecode::Raw::SetVarArray), 
-        an_instance_of(Gecode::Raw::IntVar),
-        an_instance_of(Gecode::Raw::SetVar))
-    end
-  end
-  
-  it 'should constrain the specified element of an enum of sets' do
-    @sets[@index].must_be.superset_of([5,7,9])
-    @model.solve!
-    @sets[@index.value].value.should include(5,7,9)
-  end
-  
-  it_should_behave_like 'selection constraint'
-end
-
-describe Gecode::Constraints::SetEnum::Selection, ' (union)' do
-  include GecodeR::Specs::SetHelper
-
-  before do
-    @model = SelectionSampleProblem.new
-    @sets = @model.sets
-    @set = @model.set
-    @target = @model.target
-    @model.branch_on @model.wrap_enum([@target, @set])
-    @stub = @sets[@set].union
-    
-    @expect_constrain_equal = lambda do
-      Gecode::Raw.should_receive(:selectUnion).once.with( 
-        an_instance_of(Gecode::Raw::Space),
-        an_instance_of(Gecode::Raw::SetVarArray), 
-        an_instance_of(Gecode::Raw::SetVar), 
-        an_instance_of(Gecode::Raw::SetVar))
-    end
-  end
-  
-  it 'should constrain the selected union of an enum of sets' do
-    @sets[@set].union.must_be.subset_of([5,7,9])
-    @sets[@set].union.must_be.superset_of([5])
-    @model.solve!
-    union = @set.value.inject([]) do |union, i|
-      union += @sets[i].value.to_a
-    end.uniq
-    union.should include(5)
-    (union - [5,7,9]).should be_empty
-  end
-  
-  it_should_behave_like 'selection constraint'
-end
-
-describe Gecode::Constraints::SetEnum::Selection, ' (intersection)' do
-  include GecodeR::Specs::SetHelper
-
-  before do
-    @model = SelectionSampleProblem.new
-    @sets = @model.sets
-    @set = @model.set
-    @target = @model.target
-    @model.branch_on @model.wrap_enum([@target, @set])
-    @stub = @sets[@set].intersection
-    
-    @expect_constrain_equal = lambda do
-      Gecode::Raw.should_receive(:selectInter).once.with( 
-        an_instance_of(Gecode::Raw::Space),
-        an_instance_of(Gecode::Raw::SetVarArray), 
-        an_instance_of(Gecode::Raw::SetVar), 
-        an_instance_of(Gecode::Raw::SetVar))
-    end
-  end
-  
-  it 'should constrain the selected intersection of an enum of sets' do
-    @sets[@set].intersection.must_be.subset_of([5,7,9])
-    @sets[@set].intersection.must_be.superset_of([5])
-    @model.solve!
-    intersection = @set.value.inject(nil) do |intersection, i|
-      elements = @sets[i].value.to_a
-      next elements if intersection.nil?
-      intersection &= elements
-    end.uniq
-    intersection.should include(5)
-    (intersection - [5,7,9]).should be_empty
-  end
-  
-  it_should_behave_like 'selection constraint'
-end
-
-describe Gecode::Constraints::SetEnum::Selection, ' (intersection with universe)' do
-  include GecodeR::Specs::SetHelper
-
-  before do
-    @model = SelectionSampleProblem.new
-    @sets = @model.sets
-    @set = @model.set
-    @target = @model.target
-    @model.branch_on @model.wrap_enum([@target, @set])
-    @universe = [1,2]
-    @stub = @sets[@set].intersection(:with => @universe)
-    
-    @expect_constrain_equal = lambda do
-      Gecode::Raw.should_receive(:selectInterIn).once.with( 
-        an_instance_of(Gecode::Raw::Space),
-        an_instance_of(Gecode::Raw::SetVarArray), 
-        an_instance_of(Gecode::Raw::SetVar), 
-        an_instance_of(Gecode::Raw::SetVar),
-        an_instance_of(Gecode::Raw::IntSet))
-    end
-  end
-  
-  it 'should constrain the selected intersection of an enum of sets in a universe' do
-    @sets[@set].intersection(:with => @universe).must_be.subset_of([2])
-    @model.solve!
-    intersection = @set.value.inject(@universe) do |intersection, i|
-      intersection &= @sets[i].value.to_a
-    end.uniq
-    intersection.should include(2)
-    (intersection - [1,2]).should be_empty
-  end
-  
-  it 'should allow the universe to be specified as a range' do
-    @sets[@set].intersection(:with => 1..2).must_be.subset_of([2])
-    @model.solve!
-    intersection = @set.value.inject(@universe) do |intersection, i|
-      intersection &= @sets[i].value.to_a
-    end.uniq
-    intersection.should include(2)
-    (intersection - [1,2]).should be_empty
-  end
-  
-  it 'should raise error if unknown options are specified' do
-    lambda do
-      @sets[@set].intersection(:does_not_exist => nil).must_be.subset_of([2])
-    end.should raise_error(ArgumentError)
-  end
-  
-  it 'should raise error if the universe is of the wrong type' do
-    lambda do
-      @sets[@set].intersection(:with => 'foo').must_be.subset_of([2])
-    end.should raise_error(TypeError)
-  end
-  
-  it_should_behave_like 'selection constraint'
-end
-
-describe Gecode::Constraints::SetEnum::Selection, ' (disjoint)' do
-  include GecodeR::Specs::SetHelper
-
-  before do
-    @model = SelectionSampleProblem.new
-    @sets = @model.sets
-    @set = @model.set
-    @target = @model.target
-    @model.branch_on @model.wrap_enum([@target, @set])
-    
-    @expect = lambda do |index|
-      Gecode::Raw.should_receive(:selectDisjoint)
-    end
-    
-    # For options spec.
-    @invoke_options = lambda do |hash|
-      @sets[@set].must_be.disjoint(hash)
-      @model.solve!
-    end
-    @expect_options = option_expectation do |strength, kind, reif_var|
-      @expect.call(@set)
-    end
-  end
-  
-  it 'should constrain the selected sets to be disjoint' do
-    @sets[0].must_be.superset_of([7,8])
-    @sets[1].must_be.superset_of([5,7,9])
-    @sets[2].must_be.superset_of([6,8,10])
-    @sets[@set].must_be.disjoint
-    @set.size.must > 1
-    @model.solve!.should_not be_nil
-    
-    @set.value.to_a.sort.should == [1,2]
-  end
-  
-  it 'should not allow negation' do
-    lambda{ @sets[@set].must_not_be.disjoint }.should raise_error(
-      Gecode::MissingConstraintError) 
-  end
-  
-  it_should_behave_like 'non-reifiable set constraint'
-end