gecoder 0.8.3 → 0.9.0

data/specs/constraints/constraint_receivers.rb

@@ -0,0 +1,103 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe 'constraint receiver', :shared => true do
+  it 'should raise error unless an operand of the correct type is given as lhs' do
+    lambda do
+      op = Object.new
+      class <<op
+        include Gecode::Operand
+      end
+      @receiver.new(@model, {:lhs => op, :negate => false})
+    end.should raise_error(TypeError)
+  end
+end
+
+describe Gecode::ConstraintReceiver do
+  before do
+    @model = Gecode::Model.new
+  end
+
+  it 'should raise error if the negate params is not given' do
+    lambda do
+      Gecode::ConstraintReceiver.new(@model, {:lhs => nil})
+    end.should raise_error(ArgumentError)
+  end
+    
+  it 'should raise error if the lhs params is not given' do
+    lambda do
+      Gecode::ConstraintReceiver.new(@model, {:lhs => nil})
+    end.should raise_error(ArgumentError)
+  end
+end
+
+describe Gecode::Int::IntConstraintReceiver, ' (not subclassed)' do
+  before do
+    @model = Gecode::Model.new
+    @receiver = Gecode::Int::IntConstraintReceiver
+  end
+
+  it_should_behave_like 'constraint receiver'
+end
+
+describe Gecode::IntEnum::IntEnumConstraintReceiver do
+  before do
+    @model = Gecode::Model.new
+    @receiver = Gecode::IntEnum::IntEnumConstraintReceiver
+  end
+
+  it_should_behave_like 'constraint receiver'
+end
+
+describe Gecode::Bool::BoolConstraintReceiver do
+  before do
+    @model = Gecode::Model.new
+    @receiver = Gecode::Bool::BoolConstraintReceiver
+  end
+
+  it_should_behave_like 'constraint receiver'
+end
+
+describe Gecode::BoolEnum::BoolEnumConstraintReceiver do
+  before do
+    @model = Gecode::Model.new
+    @receiver = Gecode::BoolEnum::BoolEnumConstraintReceiver
+  end
+
+  it_should_behave_like 'constraint receiver'
+end
+
+describe Gecode::Set::SetConstraintReceiver do
+  before do
+    @model = Gecode::Model.new
+    @receiver = Gecode::Set::SetConstraintReceiver
+  end
+
+  it_should_behave_like 'constraint receiver'
+end
+
+describe Gecode::SelectedSet::SelectedSetConstraintReceiver do
+  before do
+    @model = Gecode::Model.new
+    @receiver = Gecode::SelectedSet::SelectedSetConstraintReceiver
+  end
+
+  it_should_behave_like 'constraint receiver'
+end
+
+describe Gecode::SetElements::SetElementsConstraintReceiver do
+  before do
+    @model = Gecode::Model.new
+    @receiver = Gecode::SetElements::SetElementsConstraintReceiver
+  end
+
+  it_should_behave_like 'constraint receiver'
+end
+
+describe Gecode::SetEnum::SetEnumConstraintReceiver do
+  before do
+    @model = Gecode::Model.new
+    @receiver = Gecode::SetEnum::SetEnumConstraintReceiver
+  end
+
+  it_should_behave_like 'constraint receiver'
+end

data/specs/constraints/constraints.rb

@@ -1,83 +1,26 @@
 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::BoolEnum::Expression do
-  it 'should raise error unless lhs is a bool enum' do
-    lambda do
-      Gecode::Constraints::BoolEnum::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
+describe Gecode::Constraint, ' (not subclassed)' do
   before do
-    @con = Gecode::Constraints::Constraint.new(Gecode::Model.new, {})
+    @con = Gecode::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)
+    lambda{ @con.post }.should raise_error(NotImplementedError)
   end
 end
 
-describe Gecode::Constraints::Util do
+describe Gecode::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')
+      Gecode::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')
+      Gecode::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/fixnum_enum/element.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/../property_helper'
+
+class FixnumElementSampleProblem < Gecode::Model
+  attr :prices
+  attr :store
+  attr :price
+  
+  def initialize
+    prices = [17, 63, 45, 63]
+    @prices = wrap_enum(prices)
+    @store = int_var(0...prices.size)
+    @price = int_var(prices)
+    branch_on @store
+  end
+end
+
+describe Gecode::FixnumEnum::Element do
+  before do
+    @model = FixnumElementSampleProblem.new
+    @price = @model.price
+    @store = @model.store
+    @enum = @model.prices
+    
+    # For int operand producing property spec.
+    @property_types = [:fixnum_enum, :int]
+    @select_property = lambda do |fixnum_enum, int|
+      fixnum_enum[int]
+    end
+    @selected_property = @enum[@store]
+    @constraint_class = Gecode::BlockConstraint
+  end
+
+  it 'should not disturb normal array access' do
+    @enum[2].should_not be_nil
+  end
+
+  it 'should constrain the selected element' do
+    @enum[@store].must == @enum[2]
+    @model.solve!.should_not be_nil
+    @store.value.should equal(2)
+  end
+
+  it 'should be translated into an element constraint' do
+    @enum[@store].must == @price
+    @model.allow_space_access do
+      Gecode::Raw.should_receive(:element).once.with( 
+        an_instance_of(Gecode::Raw::Space), 
+        an_instance_of(Array), 
+        @store.bind, @price.bind, 
+        Gecode::Raw::ICL_DEF,
+        Gecode::Raw::PK_DEF)
+    end
+    @model.solve!
+  end
+  
+  it_should_behave_like(
+    'property that produces int operand by short circuiting equality')
+end

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
+