gecoder-with-gecode 0.8.3 → 0.9.0

data/specs/constraints/fixnum_enum/operation.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/../property_helper'
+
+Gecode::Util::SET_OPERATION_TYPES.each_pair do |operation, type|
+  describe Gecode::FixnumEnum::Operation, " (#{operation} with set variable)" do
+    before do
+      @model = Gecode::Model.new
+      @constant_lhs = @model.wrap_enum [0, 4, 7]
+      @set = @model.set_var([1], 0..20)
+      @constant_set = [2, 3, 5]
+      @rhs = @model.set_var([], 0..20)
+      @model.branch_on @model.wrap_enum([@set, @rhs])
+    
+      @property_types = [:fixnum_enum, :set]
+      @select_property = lambda do |fixnum_enum, set|
+        fixnum_enum.method(operation).call(set)
+      end
+      @selected_property = @constant_lhs.method(operation).call(@set)
+      @constraint_class = 
+        Gecode::Set::Operation::OperationConstraint
+    end
+
+    it "should translate #{operation} into an operation constraint" do
+      @model.allow_space_access do
+        Gecode::Raw.should_receive(:rel).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          an_instance_of(Gecode::Raw::IntSet), type, @set.bind, 
+          Gecode::Raw::SRT_EQ, @rhs.bind)
+      end
+      @constant_lhs.method(operation).call(@set).must == @rhs
+      @model.solve!
+    end
+
+    it "should constrain the #{operation} of the sets with variable rhs" do
+      @constant_lhs.method(operation).call(@set).must == @rhs
+      @model.solve!
+
+      s1 = @constant_lhs
+      s2 = @set.value.to_a
+      rhs = @rhs.value.to_a
+      case operation
+        when :union
+          (s1 | s2).sort.should == rhs.sort
+        when :disjoint_union
+          (s1 | s2 - (s1 & s2)).sort.should == rhs.sort
+        when :intersection
+          (s1 & s2).should == rhs
+        when :minus
+          (s1 - s2).should == rhs
+      end
+    end
+
+    it 'should not allow constant sets to be given as argument' do
+      lambda do
+        @constant_lhs.method(operation).call(@constant_set).must == @rhs
+      end.should raise_error(TypeError)
+    end
+
+    it 'should not allow all three parameters to be constant sets' do
+      lambda do
+        @constant_lhs.method(operation).call(@constant_set).must == [0]
+      end.should raise_error(TypeError)
+    end
+
+    it_should_behave_like(
+      'property that produces set operand by short circuiting set relations')
+  end
+end

data/specs/constraints/int/arithmetic.rb

@@ -0,0 +1,149 @@
+require File.dirname(__FILE__) + '/../property_helper'
+
+class ArithmeticSampleProblem < Gecode::Model
+  attr :var
+  attr :var2
+  
+  def initialize
+    @var = int_var(-9..9)
+    @var2 = int_var(0..9)
+    branch_on wrap_enum([@var, @var2])
+  end
+end
+
+describe Gecode::Int::Arithmetic, ' (abs)' do
+  before do
+    @model = ArithmeticSampleProblem.new
+    @var = @model.var
+
+    @property_types = [:int]
+    @select_property = lambda do |int|
+      int.abs
+    end
+    @selected_property = @var.abs
+    @constraint_class = Gecode::BlockConstraint
+  end
+  
+  it 'should constrain the absolute value' do
+    @var.must < 0
+    @var.abs.must == 5
+    @model.solve!.var.value.should == -5
+  end
+
+  it 'should translate into an abs constraint' do
+    Gecode::Raw.should_receive(:abs)
+    @var.abs.must == 5
+    @model.solve!
+  end
+
+  it_should_behave_like(
+    'property that produces int operand by short circuiting equality')
+end
+
+describe Gecode::Int::Arithmetic, ' (multiplication)' do
+  before do
+    @model = ArithmeticSampleProblem.new
+    @var = @model.var
+    @var2 = @model.var2
+
+    @property_types = [:int, :int]
+    @select_property = lambda do |int1, int2|
+      int1 * int2
+    end
+    @selected_property = @var * @var2
+    @constraint_class = Gecode::BlockConstraint
+  end
+  
+  it 'should constrain the value of the multiplication' do
+    (@var * @var2).must == 56
+    sol = @model.solve!
+    [sol.var.value, sol.var2.value].sort.should == [7, 8]
+  end
+
+  it 'should translate into a mult constraint' do
+    Gecode::Raw.should_receive(:mult)
+    (@var * @var2).must == 56
+    @model.solve!
+  end
+  
+  it_should_behave_like(
+    'property that produces int operand by short circuiting equality')
+end
+
+describe Gecode::Int::Arithmetic, ' (squared)' do
+  before do
+    @model = ArithmeticSampleProblem.new
+    @var = @model.var
+    
+    @property_types = [:int]
+    @select_property = lambda do |int|
+      int.squared
+    end
+    @selected_property = @var.squared
+    @constraint_class = Gecode::BlockConstraint
+  end
+  
+  it 'should constrain the value of the variable squared' do
+    @var.squared.must == 9
+    sol = @model.solve!
+    sol.var.value.abs.should == 3
+  end
+
+  it 'should translate into a squared constraint' do
+    Gecode::Raw.should_receive(:sqr)
+    @var.squared.must == 4
+    @model.solve!
+  end
+  
+  it_should_behave_like(
+    'property that produces int operand by short circuiting equality')
+end
+
+describe Gecode::Int::Arithmetic, ' (square root)' do
+  before do
+    @model = ArithmeticSampleProblem.new
+    @var = @model.var
+
+    @property_types = [:int]
+    @select_property = lambda do |int|
+      int.sqrt
+    end
+    @selected_property = @var.sqrt
+    @constraint_class = Gecode::BlockConstraint
+  end
+  
+  it 'should constrain the square root of the variable' do
+    @var.square_root.must == 3
+    sol = @model.solve!
+    Math.sqrt(sol.var.value).floor.should == 3
+  end
+  
+  it 'should constrain the square root of the variable (2)' do
+    @var.square_root.must == 0
+    sol = @model.solve!
+    Math.sqrt(sol.var.value).floor.should == 0
+  end
+  
+  it 'should constrain the square root of the variable (3)' do
+    @var.must < 0
+    @var.square_root.must == 0
+    lambda{ @model.solve! }.should raise_error(Gecode::NoSolutionError)
+  end
+  
+  it 'should round down the square root' do
+    @var.must > 4
+    @var.square_root.must == 2
+    sol = @model.solve!
+    sol.var.value.should be_between(5,8)
+  end
+  
+  it 'should translate into a square root constraint' do
+    Gecode::Raw.should_receive(:sqrt)
+    @var.sqrt.must == 2
+    @model.solve!
+  end
+
+  it_should_behave_like(
+    'property that produces int operand by short circuiting equality')
+end
+

data/specs/constraints/int/channel.rb

@@ -0,0 +1,101 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+class BoolChannelSampleProblem < Gecode::Model
+  attr :bool_enum
+  attr :bool
+  attr :int
+  
+  def initialize
+    @bool_enum = bool_var_array(4)
+    @int = int_var(0..3)
+    @bool = bool_var
+    
+    branch_on @int
+  end
+end
+
+describe Gecode::Int::Channel, ' (one int and one bool variable)' do
+  before do
+    @model = BoolChannelSampleProblem.new
+    @bool = @model.bool_var
+    @int = @model.int_var
+
+    @types = [:int, :bool]
+    @invoke = lambda do |receiver, bool, hash| 
+      receiver.equal(bool, hash)
+      @model.solve!
+    end
+    @expect = lambda do |var1, var2, opts, reif_var|
+      Gecode::Raw.should_receive(:channel).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        var1, var2, *opts)
+    end
+  end
+
+  it 'should not shadow linear boolean constraints' do
+    lambda do
+      (@bool + @bool).must == @bool
+      @model.solve!
+    end.should_not raise_error 
+  end
+
+  it 'should constrain the int variable to be 1 when the boolean variable is true' do
+    @bool.must_be.true
+    @int.must == @bool
+    @model.solve!
+    @int.value.should == 1
+  end
+  
+  it 'should constrain the int variable to be 0 when the boolean variable is false' do
+    @bool.must_be.false
+    @int.must == @bool
+    @model.solve!
+    @int.value.should == 0
+  end
+
+  it_should_behave_like 'non-reifiable constraint'
+  it_should_behave_like 'non-negatable constraint'
+end
+
+describe Gecode::Int::Channel, ' (one bool and one int variable)' do
+  before do
+    @model = BoolChannelSampleProblem.new
+    @bool = @model.bool_var
+    @int = @model.int_var
+
+    @types = [:bool, :int]
+    @invoke = lambda do |receiver, int, hash| 
+      receiver.equal(int, hash)
+      @model.solve!
+    end
+    @expect = lambda do |var1, var2, opts, reif_var|
+      Gecode::Raw.should_receive(:channel).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        var2, var1, *opts)
+    end
+  end
+
+  it 'should not shadow linear boolean constraints' do
+    lambda do
+      @bool.must == @bool + @bool
+      @model.solve!
+    end.should_not raise_error 
+  end
+
+  it 'should constrain the int variable to be 1 when the boolean variable is true' do
+    @bool.must_be.true
+    @bool.must == @int
+    @model.solve!
+    @int.value.should == 1
+  end
+  
+  it 'should constrain the int variable to be 0 when the boolean variable is false' do
+    @bool.must_be.false
+    @bool.must == @int
+    @model.solve!
+    @int.value.should == 0
+  end
+
+  it_should_behave_like 'non-reifiable constraint'
+  it_should_behave_like 'non-negatable constraint'
+end

data/specs/constraints/int/domain.rb

@@ -0,0 +1,106 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+describe Gecode::Int::Domain, ' (non-range)' do
+  before do
+    @model = Gecode::Model.new
+    @domain = 0..3
+    @x = @model.int_var(@domain)
+    @non_range_domain = [1, 3]
+
+    @types = [:int]
+    @invoke = lambda do |receiver, hash| 
+      receiver.in(@non_range_domain, hash) 
+      @model.solve!
+    end
+    @expect = lambda do |var, opts, reif_var|
+      if reif_var.nil?
+        Gecode::Raw.should_receive(:dom).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          var, an_instance_of(Gecode::Raw::IntSet), 
+          *opts)
+      else
+        Gecode::Raw.should_receive(:dom).once.with(
+          an_instance_of(Gecode::Raw::Space), 
+          var, an_instance_of(Gecode::Raw::IntSet), 
+          reif_var, *opts)
+      end
+    end
+  end
+
+  it 'should constrain the domain of the variable' do
+    @x.must_be.in @non_range_domain
+    @model.solve!
+
+    @x.should have_domain(@non_range_domain)
+  end
+
+  it 'should handle negation' do
+    @x.must_not_be.in @non_range_domain
+    @model.solve!
+
+    @x.should have_domain(@domain.to_a - @non_range_domain.to_a)
+  end
+  
+  it_should_behave_like 'reifiable constraint'
+end
+
+describe Gecode::Int::Domain, ' (range)' do
+  before do
+    @model = Gecode::Model.new
+    @domain = 0..3
+    @operand = @x = @model.int_var(@domain)
+    @range_domain = 1..2
+    @three_dot_range_domain = 1...2
+    
+    @types = [:int]
+    @invoke = lambda do |receiver, hash| 
+      receiver.in(@range_domain, hash) 
+      @model.solve!
+    end
+    @expect = lambda do |var, opts, reif_var|
+      @model.allow_space_access do
+        if reif_var.nil?
+          Gecode::Raw.should_receive(:dom).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            var, @range_domain.first, @range_domain.last,
+            *opts)
+        else
+          Gecode::Raw.should_receive(:dom).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            var, @range_domain.first, @range_domain.last,
+            reif_var, *opts)
+        end
+      end
+    end
+  end
+
+  it 'should constrain the domain of the variable' do
+    @x.must_be.in @range_domain
+    @model.solve!
+
+    @x.should have_domain(@range_domain)
+  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 treat three dot ranges correctly' do
+    @x.must_be.in @three_dot_range_domain
+    @model.solve!
+
+    @x.should have_domain(@three_dot_range_domain)
+  end
+
+  it 'should handle three dot range with negation' do
+    @x.must_not_be.in @three_dot_range_domain
+    @model.solve!
+
+    @x.should have_domain(@domain.to_a - @three_dot_range_domain.to_a)
+  end
+  
+  it_should_behave_like 'reifiable constraint'
+end

data/specs/constraints/int/linear.rb

@@ -0,0 +1,183 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+# This is neither an operand or a constraint spec. It is mostly a sanity
+# check.
+
+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
+
+describe Gecode::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
+    @operand = @x + @y
+  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 reification (1)' do
+    bool = @model.bool_var
+    (@x + @y).must.equal(0, :reify => bool)
+    bool.must_be.false
+    sol = @model.solve!
+    x = sol.x.value
+    y = sol.y.value
+    (x + y).should_not be_zero
+  end
+
+  it 'should handle reification (2)' do
+    bool = @model.bool_var
+    (@x + @y).must.equal(0, :reify => bool)
+    bool.must_be.true
+    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 handle linear expressions as right hand side with variable as left hand side' do
+    @x.must == @z + @y
+    sol = @model.solve!
+    x = sol.x.value
+    y = sol.y.value
+    z = sol.z.value
+    x.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
+end

data/specs/constraints/int/linear_properties.rb

@@ -0,0 +1,97 @@
+require File.dirname(__FILE__) + '/../property_helper'
+
+class LinearPropertySampleProblem < Gecode::Model
+  attr :x
+  attr :y
+  attr :z
+  
+  def initialize
+    @x = self.int_var(0..2)
+    @y = self.int_var(-3..3)
+    @z = self.int_var(0..10)
+    branch_on wrap_enum([@x, @y, @z])
+  end
+end
+
+describe Gecode::Int::Linear, ' (+ property)' do
+  before do
+    @model = LinearPropertySampleProblem.new
+    @x = @model.x
+    @y = @model.y
+    @z = @model.z
+
+    # For int operand producing property spec.
+    @property_types = [:int, :int]
+    @select_property = lambda do |int1, int2|
+      int1 + int2
+    end
+    @selected_property = @x + @y
+    @constraint_class = 
+      Gecode::Int::Linear::LinearRelationConstraint
+  end
+
+  it 'should constrain the sum' do
+    (@x + @y).must == 5
+    @model.solve!
+    (@x.value + @y.value).should == 5
+  end
+
+  it_should_behave_like(
+    'property that produces int operand by short circuiting relations')
+end
+
+describe Gecode::Int::Linear, ' (- property)' do
+  before do
+    @model = LinearPropertySampleProblem.new
+    @x = @model.x
+    @y = @model.y
+    @z = @model.z
+
+    # For int operand producing property spec.
+    @property_types = [:int, :int]
+    @select_property = lambda do |int1, int2|
+      int1 - int2
+    end
+    @selected_property = @x - @y
+    @constraint_class = 
+      Gecode::Int::Linear::LinearRelationConstraint
+  end
+
+  it 'should constrain the difference' do
+    (@x - @y).must == 1
+    @model.solve!
+    (@x.value - @y.value).should == 1
+  end
+
+  it_should_behave_like(
+    'property that produces int operand by short circuiting relations')
+end
+
+describe Gecode::Int::Linear, ' (* property)' do
+  before do
+    @model = LinearPropertySampleProblem.new
+    @x = @model.x
+    @y = @model.y
+    @z = @model.z
+
+    # For int operand producing property spec.
+    @property_types = [:int]
+    @select_property = lambda do |int|
+      int * 17
+    end
+    @selected_property = @x * 2
+    @constraint_class = 
+      Gecode::Int::Linear::LinearRelationConstraint
+  end
+
+  it 'should constrain the value times a constant' do
+    (@x * 2).must == 4
+    @model.solve!
+    (@x.value * 2).should == 4
+  end
+
+  it_should_behave_like(
+    'property that produces int operand by short circuiting relations')
+end
+
+