gecoder 0.8.3 → 0.9.0

data/specs/int_var.rb

@@ -1,4 +1,5 @@
 require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/constraints/property_helper'
 
 describe 'non-empty int variable', :shared => true do
   it 'should have min equal to the lower domain bound' do
@@ -35,18 +36,22 @@ describe 'non-empty int variable', :shared => true do
   it 'should have a zero degree' do
     @var.degree.should be_zero
   end
+
+  it 'should return the correct domain through #domain' do
+    @var.domain.to_a.should == @domain.to_a
+  end
+
+  it_should_behave_like 'int var operand'
 end
 
-describe Gecode::FreeIntVar, ' (with range domain of size > 1)' do
+describe Gecode::IntVar, ' (with range domain of size > 1)' do
   before do
     @range = -4..3
     @domain = @range.to_a
-    model = Gecode::Model.new
-    @var = model.int_var(@range)
+    @model = Gecode::Model.new
+    @operand = @var = @model.int_var(@range)
   end
   
-  it_should_behave_like 'non-empty int variable'
-  
   it 'should not be assigned' do
     @var.should_not be_assigned
   end
@@ -58,28 +63,28 @@ describe Gecode::FreeIntVar, ' (with range domain of size > 1)' do
   it 'should raise error when trying to access assigned value' do
     lambda{ @var.value }.should raise_error(RuntimeError)
   end
+
+  it_should_behave_like 'non-empty int variable'
 end
 
-describe Gecode::FreeIntVar, ' (defined with three-dot range)' do
+describe Gecode::IntVar, ' (defined with three-dot range)' do
   before do
     @range = -4...3
     @domain = @range.to_a
-    model = Gecode::Model.new
-    @var = model.int_var(@range)
+    @model = Gecode::Model.new
+    @operand = @var = @model.int_var(@range)
   end
   
   it_should_behave_like 'non-empty int variable'
 end
 
-describe Gecode::FreeIntVar, ' (with non-range domain of size > 1)' do
+describe Gecode::IntVar, ' (with non-range domain of size > 1)' do
   before do
     @domain = [-3, -2, -1, 1]
-    model = Gecode::Model.new
-    @var = model.int_var(@domain)
+    @model = Gecode::Model.new
+    @operand = @var = @model.int_var(@domain)
   end
 
-  it_should_behave_like 'non-empty int variable'
-  
   it 'should not be assigned' do
     @var.should_not be_assigned
   end
@@ -91,17 +96,17 @@ describe Gecode::FreeIntVar, ' (with non-range domain of size > 1)' do
   it 'should not contain the domain\'s holes' do
     @var.should_not include(0)
   end
+  
+  it_should_behave_like 'non-empty int variable'
 end
 
-describe Gecode::FreeIntVar, ' (with a domain of size 1)' do
+describe Gecode::IntVar, ' (with a domain of size 1)' do
   before do
     @domain = [1]
-    model = Gecode::Model.new
-    @var = model.int_var(*@domain)
+    @model = Gecode::Model.new
+    @operand = @var = @model.int_var(*@domain)
   end
   
-  it_should_behave_like 'non-empty int variable'
-  
   it 'should be assigned' do
     @var.should be_assigned
   end
@@ -109,13 +114,15 @@ describe Gecode::FreeIntVar, ' (with a domain of size 1)' do
   it 'should be a range domain' do
     @var.should be_range
   end
+  
+  it_should_behave_like 'non-empty int variable'
 end
 
-describe Gecode::FreeIntVar, ' (assigned)' do
+describe Gecode::IntVar, ' (assigned)' do
   before do
     @domain = 1
-    model = Gecode::Model.new
-    @var = model.int_var(*@domain)
+    @model = Gecode::Model.new
+    @operand = @var = @model.int_var(*@domain)
   end
 
   it 'should be assigned' do
@@ -125,13 +132,19 @@ describe Gecode::FreeIntVar, ' (assigned)' do
   it 'should give the assigned number when inspecting' do
     @var.inspect.should include(" #{@domain[0]}>")
   end
+
+  it 'should return the correct domain through #domain' do
+    @var.domain.to_a.should == [@domain]
+  end
+
+  it_should_behave_like 'int var operand'
 end
 
-describe Gecode::FreeIntVar, ' (not assigned)' do
+describe Gecode::IntVar, ' (not assigned)' do
   before do
     @domain = 1..2
-    model = Gecode::Model.new
-    @var = model.int_var(@domain)
+    @model = Gecode::Model.new
+    @operand = @var = @model.int_var(@domain)
   end
 
   it 'should not be assigned' do
@@ -141,4 +154,10 @@ describe Gecode::FreeIntVar, ' (not assigned)' do
   it 'should give the domain range when inspecting' do
     @var.inspect.should include(" #{@domain.first}..#{@domain.last}>")
   end
-end
+
+  it 'should return the correct domain through #domain' do
+    @var.domain.to_a.should == @domain.to_a
+  end
+
+  it_should_behave_like 'int var operand'
+end

data/specs/model.rb

@@ -265,4 +265,61 @@ describe Gecode::Model, ' (space access restriction)' do
       end
     end.should_not raise_error(RuntimeError)
   end
-end
+end
+
+describe Gecode::Model, ' (accessible variable creation)' do
+  before do
+    @model = Class.new(Gecode::Model).new
+  end
+
+  it 'should allow creation of named variable using #foo_is_a' do
+    var = @model.int_var(17)
+    lambda{ @model.foo }.should raise_error(NoMethodError)
+    @model.instance_eval{ foo_is_a var }
+    lambda{ @model.foo }.should_not raise_error
+    @model.foo.should == var
+  end
+
+  it 'should allow creation of named variable using #foo_is_an' do
+    var = @model.int_var(17)
+    lambda{ @model.foo }.should raise_error(NoMethodError)
+    @model.instance_eval{ foo_is_an var }
+    lambda{ @model.foo }.should_not raise_error
+    @model.foo.should == var
+  end
+
+  it 'should only allow one argument to be given to #foo_is_a' do
+    lambda do
+      @model.instance_eval{ foo_is_a }
+    end.should raise_error(ArgumentError)
+    lambda do
+      @model.instance_eval{ foo_is_a bool_var, bool_var }
+    end.should raise_error(ArgumentError)
+  end
+
+  it 'should only define the variable in the current instance' do
+    klass = Class.new Gecode::Model
+    model_a = klass.new
+    model_b = klass.new
+
+    model_a.instance_eval{ bar_is_a bool_var }
+    lambda{ model_a.bar }.should_not raise_error
+    lambda{ model_b.bar }.should raise_error(NoMethodError)
+  end
+
+  it 'should raise error if a method would be overwritten' do
+    var = @model.int_var(17)
+    lambda{ @model.class }.should_not raise_error
+    lambda do
+      @model.instance_eval{ class_is_an var } 
+    end.should raise_error(ArgumentError)
+  end
+
+  it 'should raise error if an instance variable would be overwritten' do
+    @model.instance_eval{ @foo = 17 }
+    var = @model.int_var(17)
+    lambda do
+      @model.instance_eval{ foo_is_a var } 
+    end.should raise_error(ArgumentError)
+  end
+end

data/specs/model_sugar.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Gecode, ' (Model sugar)' do
+  it 'should provide #solve as sugar for constructing a model and running solve!' do
+    Gecode.solve do
+      numbers_is_an int_var_array(2, 0..5)
+      x, y = numbers
+      (x * y).must == 25
+      branch_on numbers
+    end.numbers.values.should == [5,5]
+  end
+
+  it 'should provide #maximize as sugar for constructing a model and running maximize!' do
+    Gecode.maximize :z do
+      z_is_an int_var
+      x, y = vars = int_var_array(2, 0..5)
+      (x*2 - y).must == z
+      branch_on vars
+    end.z.value.should equal(10)
+  end
+
+  it 'should provide #minimize as sugar for constructing a model and running minimize!' do
+    Gecode.minimize :z do
+      z_is_an int_var
+      x, y = vars = int_var_array(2, 0..5)
+      (x*2 - y).must == z
+      branch_on vars
+    end.z.value.should equal(-5)
+  end
+end

data/specs/search.rb

@@ -201,16 +201,35 @@ describe Gecode::Model, ' (without solution)' do
   end
   
   it 'should return nil when calling #solution' do
-    @model.var.must < 0
     @model.solution{ |s| 'test' }.should be_nil
   end
+
+  it 'should not yield anything to #each_solution' do 
+    @model.each_solution{ |s| violated }
+  end
   
-  it 'should return nil when calling #solve!' do
-    @model.solve!.should be_nil
+  it 'should raise NoSolutionError when calling #solve!' do
+    lambda do 
+      @model.solve!
+    end.should raise_error(Gecode::NoSolutionError)
   end
   
-  it 'should return nil when calling #optimize!' do
-    @model.optimize!{}.should be_nil
+  it 'should raise NoSolutionError when calling #optimize!' do
+    lambda do 
+      @model.optimize!{}
+    end.should raise_error(Gecode::NoSolutionError)
+  end
+
+  it 'should raise NoSolutionError when calling #minimize!' do
+    lambda do 
+      @model.optimize!{}
+    end.should raise_error(Gecode::NoSolutionError)
+  end
+
+  it 'should raise NoSolutionError when calling #maximize!' do
+    lambda do 
+      @model.maximize!(:var)
+    end.should raise_error(Gecode::NoSolutionError)
   end
 end
 

data/specs/selected_set.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Gecode::SelectedSet::SelectedSetOperand do
+  before do
+    @model = Gecode::Model.new
+    set_enum = @model.set_var_array(5, [], 0..9)
+    set = @model.set_var([], 0..4)
+    @operand = Gecode::SelectedSet::SelectedSetOperand.new(
+      set_enum, set)
+  end
+
+  it 'should implement #model' do
+    @operand.model.should be_kind_of(Gecode::Model)
+  end
+
+  it 'should implement #to_selected_set' do
+    enum, set = @operand.to_selected_set
+    enum.should be_respond_to(:to_set_enum)
+    set.should be_respond_to(:to_set_var)
+    @model.solve!
+    set_var = set.to_set_var
+    ((set_var.lower_bound == []) && 
+     (set_var.upper_bound == Gecode::Model::LARGEST_SET_BOUND)).should_not(
+      be_true)
+    enum.each do |element|
+      set_var = element.to_set_var
+      ((set_var.lower_bound == []) && 
+       (set_var.upper_bound == Gecode::Model::LARGEST_SET_BOUND)).should_not(
+        be_true)
+    end
+  end
+
+  it 'should implement #must' do
+    receiver = @operand.must
+    receiver.should be_kind_of(
+      Gecode::SelectedSet::SelectedSetConstraintReceiver)
+  end
+end
+

data/specs/set_elements.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Gecode::SelectedSet::SelectedSetOperand do
+  before do
+    @model = Gecode::Model.new
+    @set = @model.set_var([], 0..4)
+    @operand = Gecode::SetElements::SetElementsOperand.new(@set)
+  end
+
+  it 'should implement #model' do
+    @operand.model.should be_kind_of(Gecode::Model)
+  end
+
+  it 'should implement #to_set_elements' do
+    set = @operand.to_set_elements
+    set.should be_respond_to(:to_set_var)
+    @model.solve!
+    set_var = set.to_set_var
+    ((set_var.lower_bound == []) && 
+     (set_var.upper_bound == Gecode::Model::LARGEST_SET_BOUND)).should_not(
+      be_true)
+  end
+
+  it 'should implement #must' do
+    receiver = @operand.must
+    receiver.should be_kind_of(
+      Gecode::SetElements::SetElementsConstraintReceiver)
+  end
+
+  it 'should be produces by SetOperand#elements' do
+    @set.elements.should be_respond_to(:to_set_elements)
+  end
+end
+

data/specs/set_var.rb

@@ -1,9 +1,9 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/constraints/property_helper'
 
-describe Gecode::FreeSetVar, '(not assigned)' do
+describe Gecode::SetVar, '(not assigned)' do
   before do
-    model = Gecode::Model.new
-    @var = model.set_var(1..3, 0..4)
+    @model = Gecode::Model.new
+    @operand = @var = @model.set_var(1..3, 0..4)
   end
   
   it 'should not be assigned' do
@@ -14,6 +14,11 @@ describe Gecode::FreeSetVar, '(not assigned)' do
     @var.inspect.should include('lub-range')
     @var.inspect.should include('glb-range')
   end
+
+  it 'should allow inspection even when the bounds are too large to display' do
+    var = @model.set_var
+    var.inspect.should include('too large')
+  end
   
   it 'should report the correct bounds' do
     @var.lower_bound.sort.to_a.should == (1..3).to_a
@@ -42,13 +47,15 @@ describe Gecode::FreeSetVar, '(not assigned)' do
       lower_bound.each{}
     end.should_not raise_error
   end
+
+  it_should_behave_like 'set var operand'
 end
 
-describe Gecode::FreeSetVar, '(assigned)' do
+describe Gecode::SetVar, '(assigned)' do
   before do
-    model = Gecode::Model.new
-    @var = model.set_var(1, 1)
-    model.solve!
+    @model = Gecode::Model.new
+    @operand = @var = @model.set_var(1, 1)
+    @model.solve!
   end
   
   it 'should be assigned' do
@@ -65,4 +72,11 @@ describe Gecode::FreeSetVar, '(assigned)' do
     @var.lower_bound.to_a.should == [1]
     @var.value.to_a.should == [1]
   end
+
+  it 'should allow inspection even when the bounds are too large to display' do
+    var = @model.set_var(0..10**4, 0..10**4)
+    var.inspect.should include('too large')
+  end
+
+  it_should_behave_like 'set var operand'
 end

data/specs/spec_helper.rb

@@ -5,16 +5,25 @@ require File.dirname(__FILE__) + '/../lib/gecoder'
 module CustomVarMatchers
   class HaveDomain
     def initialize(expected)
-      @expected = expected.to_a
+      @expected = expected
     end
     
     def matches?(target)
       @target = target
-      return false unless @target.size == @expected.size
-      @expected.each do |element|
-        return false unless @target.include? element
+      if @expected.kind_of? Range
+        last = @expected.end
+        last -= 1 if @expected.exclude_end?
+        return @target.range? && @expected.begin == @target.min && 
+          last == @target.max
+      else
+        @expected = @expected.to_a
+        return false unless @target.size == @expected.size
+        @expected.each do |element|
+          return false unless @target.include? element
+        end
+        return true
       end
-      return true
+      return false
     end
     
     def failure_message
@@ -39,7 +48,9 @@ module CustomVarMatchers
     
     def matches?(target)
       @target = target
-      return @target.lower_bound.to_a == @expected_glb &&
+      return @target.lower_bound.size == @expected_glb.size &&
+        @target.upper_bound.size == @expected_lub.size &&
+        @target.lower_bound.to_a == @expected_glb &&
         @target.upper_bound.to_a == @expected_lub
     end
     
@@ -63,3 +74,192 @@ end
 Spec::Runner.configure do |config|
   config.include(CustomVarMatchers)
 end
+
+
+# Help methods for the GecodeR specs. 
+module GecodeR::Specs
+  module SetHelper
+    module_function
+  
+    # Returns the arguments that should be used in a partial mock to expect the
+    # specified constant set (possibly an array of arguments).
+    def expect_constant_set(constant_set)
+      if constant_set.kind_of? Range
+        return constant_set.first, constant_set.last
+      elsif constant_set.kind_of? Fixnum
+        constant_set
+      else
+        an_instance_of(Gecode::Raw::IntSet)
+      end
+    end
+  end
+
+  module GeneralHelper
+    module_function
+
+    # Produces a base operand that can be used to mock specific types of
+    # operands.
+    def general_operand_base(model)
+      mock_op_class = Class.new
+      mock_op_class.class_eval do
+        attr :model
+
+        def bind
+          raise 'Bind should not be called directly for an operand.'
+        end
+        alias_method :bind_array, :bind
+      end
+      op = mock_op_class.new
+      op.instance_eval do
+        @model = model
+      end
+      return op
+    end
+
+    # Produces a general int operand. The method returns two objects: 
+    # the operand itself and the variable it returns when #to_int_var
+    # is called.
+    def general_int_operand(model)
+      op = general_operand_base(model)
+      
+      int_var = model.int_var
+      class <<op
+        include Gecode::Int::IntOperand
+        attr :model
+      end
+      op.stub!(:to_int_var).and_return int_var
+
+      return op, int_var
+    end
+
+    # Produces a general bool operand. The method returns two objects: 
+    # the operand itself and the variable it returns when #to_bool_var
+    # is called.
+    def general_bool_operand(model)
+      op = general_operand_base(model)
+
+      bool_var = model.bool_var
+      class <<op
+        include Gecode::Bool::BoolOperand
+        attr :model
+      end
+      op.stub!(:to_bool_var).and_return bool_var
+
+      return op, bool_var
+    end
+
+    # Produces a general set operand. The method returns two objects: 
+    # the operand itself and the variable it returns when #to_set_var
+    # is called.
+    def general_set_operand(model)
+      op = general_operand_base(model)
+
+      set_var = model.set_var
+      class <<op
+        include Gecode::Set::SetOperand
+        attr :model
+      end
+      op.stub!(:to_set_var).and_return set_var
+
+      return op, set_var
+    end
+    
+    # Produces a general int enum operand. The method returns two objects: 
+    # the operand itself and the variable it returns when #to_int_enum
+    # is called.
+    def general_int_enum_operand(model)
+      op = general_operand_base(model)
+      
+      int_enum = model.int_var_array(5)
+      class <<op
+        include Gecode::IntEnum::IntEnumOperand
+        attr :model
+      end
+      op.stub!(:to_int_enum).and_return int_enum
+
+      return op, int_enum
+    end
+
+    # Produces a general bool enum operand. The method returns two objects: 
+    # the operand itself and the variable it returns when #to_bool_enum
+    # is called.
+    def general_bool_enum_operand(model)
+      op = general_operand_base(model)
+      
+      bool_enum = model.bool_var_array(5)
+      class <<op
+        include Gecode::BoolEnum::BoolEnumOperand
+        attr :model
+      end
+      op.stub!(:to_bool_enum).and_return bool_enum
+
+      return op, bool_enum
+    end
+
+    # Produces a general set enum operand. The method returns two objects: 
+    # the operand itself and the variable it returns when #to_set_enum
+    # is called.
+    def general_set_enum_operand(model)
+      op = general_operand_base(model)
+      
+      set_enum = model.set_var_array(5)
+      class <<op
+        include Gecode::SetEnum::SetEnumOperand
+        attr :model
+      end
+      op.stub!(:to_set_enum).and_return set_enum
+
+      return op, set_enum
+    end
+
+    # Produces a general selected set operand. The method returns two objects: 
+    # the operand itself and the array of variables corresponding to the
+    # operands it returns when # #to_selected_set is called.
+    def general_selected_set_operand(model)
+      set_enum, set_enum_var = general_set_enum_operand(model)
+      set, set_var = general_set_operand(model)
+      op = Gecode::SelectedSet::SelectedSetOperand.new(
+        set_enum, set)
+      return op, [set_enum_var, set_var]
+    end
+
+    # Produces a general set elements  operand. The method returns two 
+    # objects: the operand itself and the set var corresponding to the
+    # operands it returns when # #to_selected_set is called.
+    def general_set_elements_operand(model)
+      set, set_var = general_set_operand(model)
+      op = Gecode::SetElements::SetElementsOperand.new(set)
+      return op, set_var
+    end
+
+    # Produces a general fixnum enum operand. The method returns two objects: 
+    # the operand itself and the variable it returns when #to_fixnum_enum
+    # is called.
+    def general_fixnum_enum_operand(model)
+      op = general_operand_base(model)
+      
+      fixnum_enum = model.wrap_enum([1, -4, 9, 4, 0])
+      class <<op
+        include Gecode::FixnumEnum::FixnumEnumOperand
+        attr :model
+      end
+      op.stub!(:to_fixnum_enum).and_return fixnum_enum
+
+      return op, fixnum_enum
+    end
+
+    # Produces an array of general operands of the specified types.
+    # Returns an array of operands and an array of their variables.
+    def produce_general_arguments(property_types)
+      operands = []
+      variables = []
+      property_types.each do |type|
+        op, var = eval "general_#{type}_operand(@model)"
+        operands << op
+        variables << var
+      end
+      return operands, variables
+    end
+  end
+end
+include GecodeR::Specs::GeneralHelper