gecoder 0.8.2 → 0.8.3

data/specs/constraints/channel.rb

@@ -26,10 +26,23 @@ class BoolChannelSampleProblem < Gecode::Model
     @int = int_var(0..3)
     @bool = bool_var
     
-    branch_on wrap_enum([@int])
+    branch_on @int
   end
 end
 
+class SetChannelSampleProblem < Gecode::Model
+  attr :bool_enum
+  attr :set
+  
+  def initialize
+    @bool_enum = bool_var_array(4)
+    @set = set_var([], 0..3)
+    
+    branch_on @bool_enum
+  end
+end
+
+
 describe Gecode::Constraints::IntEnum::Channel, ' (two int enums)' do
   before do
     @model = ChannelSampleProblem.new
@@ -73,10 +86,10 @@ describe Gecode::Constraints::IntEnum::Channel, ' (two int enums)' do
     lambda{ @elements.must.channel 'hello' }.should raise_error(TypeError) 
   end
   
-  it_should_behave_like 'reifiable constraint'
+  it_should_behave_like 'non-reifiable constraint'
 end
 
-describe Gecode::Constraints::IntEnum::Channel, ' (one int enum and one set enum)' do
+describe Gecode::Constraints::SetEnum::Channel::IntChannelConstraint, ' (channel with set as right hand side)' do
   before do
     @model = ChannelSampleProblem.new
     @positions = @model.positions
@@ -113,7 +126,7 @@ describe Gecode::Constraints::IntEnum::Channel, ' (one int enum and one set enum
   it_should_behave_like 'non-reifiable set constraint'
 end
 
-describe Gecode::Constraints::SetEnum, ' (channel with set as left hand side)' do
+describe Gecode::Constraints::SetEnum::Channel::IntChannelConstraint, ' (channel with set as left hand side)' do
   before do
     @model = ChannelSampleProblem.new
     @positions = @model.positions
@@ -354,3 +367,88 @@ describe Gecode::Constraints::BoolEnum::Channel, ' (int variable as lhs with boo
   
   it_should_behave_like 'channel constraint between bool enum and int variable'
 end
+
+# Requires @model, @bool_enum and @set. Also requires @place_constraint which 
+# is a method that takes four variables: a boolean enum, a set variable,
+# whether or not the constraint should be negated and a hash of options, and 
+# places the channel constraint on them.
+describe 'channel constraint between set variable and bool enum', :shared => true do
+  before do
+    @invoke_options = lambda do |hash| 
+      @place_constraint.call(@bools, @set, false, hash)
+      @model.solve!
+    end
+    @expect_options = option_expectation do |strength, kind, reif_var|
+      Gecode::Raw.should_receive(:channel).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        an_instance_of(Gecode::Raw::BoolVarArray),
+        an_instance_of(Gecode::Raw::SetVar))
+    end
+  end
+  
+  it 'should channel the bool enum with the set variable' do
+    @set.must_be.superset_of [0, 2]
+    @place_constraint.call(@bools, @set, false, {})
+    @model.solve!.should_not be_nil
+    set_values = @set.value
+    @bools.values.each_with_index do |bool, index|
+      bool.should == set_values.include?(index)
+    end
+  end
+  
+  it 'should not allow negation' do
+    lambda do
+      @place_constraint.call(@bools, @set, true, {})
+    end.should raise_error(Gecode::MissingConstraintError) 
+  end
+  
+  it_should_behave_like 'non-reifiable set constraint'
+end
+
+describe Gecode::Constraints::Set::Channel, ' (set variable as lhs with bool enum)' do
+  before do
+    @model = SetChannelSampleProblem.new
+    @bools = @model.bool_enum
+    @set = @model.set
+    
+    @place_constraint = lambda do |bools, set, negate, options|
+      unless negate
+        set.must.channel(bools, options)
+      else
+        set.must_not.channel(bools, options)
+      end
+    end
+  end
+
+  it 'should raise error if a boolean enum is not given as right hand side' do
+    lambda do
+      @set.must.channel 'hello'
+    end.should raise_error(TypeError) 
+  end
+  
+  it_should_behave_like 'channel constraint between set variable and bool enum'
+end
+
+describe Gecode::Constraints::Set::Channel, ' (bool enum as lhs with set variable)' do
+  before do
+    @model = SetChannelSampleProblem.new
+    @bools = @model.bool_enum
+    @set = @model.set
+    
+    @place_constraint = lambda do |bools, set, negate, options|
+      unless negate
+        bools.must.channel(set, options)
+      else
+        bools.must_not.channel(set, options)
+      end
+    end
+  end
+
+  it 'should raise error if an integer variable is not given as right hand side' do
+    lambda do
+      @bools.must.channel 'hello'
+    end.should raise_error(TypeError) 
+  end
+  
+  it_should_behave_like 'channel constraint between set variable and bool enum'
+end

data/specs/constraints/extensional.rb

@@ -44,7 +44,7 @@ describe 'tuple constraint', :shared => true do
   it_should_behave_like 'non-reifiable constraint'
 end
 
-describe Gecode::Constraints::IntEnum::Extensional do
+describe Gecode::Constraints::IntEnum::Extensional, ' (tuple constraint)' do
   before do
     @model = Gecode::Model.new
     @tuples = [[1,7], [5,1]]
@@ -77,7 +77,7 @@ describe Gecode::Constraints::IntEnum::Extensional do
   it_should_behave_like 'tuple constraint'
 end
 
-describe Gecode::Constraints::BoolEnum::Extensional do
+describe Gecode::Constraints::BoolEnum::Extensional, ' (tuple constraint)' do
   before do
     @model = Gecode::Model.new
     @tuples = [[true, false, true], [false, false, true]]
@@ -109,3 +109,186 @@ describe Gecode::Constraints::BoolEnum::Extensional do
   
   it_should_behave_like 'tuple constraint'
 end
+
+# Assumes that @variables, @expected_array, @value1, @value2 (must not
+# equal @value1) and @regexp are defined. 
+describe 'regular expression constraint', :shared => true do
+  before do
+    @invoke_options = lambda do |hash| 
+      @variables.must.match(@regexp, hash)
+      @model.solve!
+    end
+    @expect_options = option_expectation do |strength, kind, reif_var|
+      Gecode::Raw.should_receive(:extensional).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        @expected_array, 
+        an_instance_of(Gecode::Raw::REG), strength, kind)
+    end
+  end
+
+  it 'should handle values grouped in a single array' do
+    @variables.must.match [@value1, @value2, @value1]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value1, @value2, @value1]
+  end
+
+  it 'should allow nested groups of values' do
+    @variables.must.match [@value1, [@value2, [@value1]]]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value1, @value2, @value1]
+  end
+  
+  it 'should handle the repeat operation' do
+    @variables.must.match [@value1, @model.repeat([@value2], 1, 2)]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value1, @value2, @value2]
+  end
+
+  it 'should handle repeat operations that do not encase constant values in arrays' do
+    @variables.must.match [@value1, @model.repeat(@value2, 1, 2)]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value1, @value2, @value2]
+  end
+
+  it 'should handle nested repeat operations' do
+    @variables.must.match [[@model.repeat(@model.repeat([@value2], 1, 3), 1, 2)]]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value2, @value2, @value2]
+  end
+
+  it 'should handle nested repeat operations (2)' do
+    @variables.must.match [[@model.repeat([@model.repeat(@value2, 1, 3)], 1, 2)]]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value2, @value2, @value2]
+  end
+
+  it 'should interpret the repeat operation with the last argument omitted as only giving a lower bound' do
+    @variables.must.match [@value1, @model.repeat([@value2], 1)]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value1, @value2, @value2]
+  end
+
+  it 'should interpret the repeat operation with all but the first argument omitted as not giving any bound' do
+    @variables.must.match [@model.repeat(@value2), @value1, @value1, @value1]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value1, @value1, @value1]
+  end
+
+  it 'should interpret the repeat operation with all but the first argument omitted as not giving any bound (2)' do
+    @variables.must.match [@model.repeat(@value2)]
+    @model.solve!.should_not be_nil
+    @variables.values.should == [@value2, @value2, @value2]
+  end
+
+  it 'should translate at_most_once(reg) to repeat(reg, 0, 1)' do
+    @model.should_receive(:repeat).once.with([@value1], 0, 1)
+    @model.at_most_once [@value1]
+  end
+
+  it 'should translate at_least_once(reg) to repeat(reg, 1)' do
+    @model.should_receive(:repeat).once.with([@value1], 1)
+    @model.at_least_once [@value1]
+  end
+
+  it 'should raise error if the right hand side is not an enumeration' do
+    lambda do 
+      @variables.must.match Object.new
+    end.should raise_error(TypeError)
+  end
+  
+  it 'should raise error if the right hand side does not a regexp of the right type' do
+    lambda do 
+      @variables.must.match [@value1, 'foo'] 
+    end.should raise_error(TypeError)
+  end
+
+  it 'should raise error if the right hand side contains a nested element of an incorrect type' do
+    lambda do 
+      @variables.must.match [@value1, [@value2, 'foo']] 
+    end.should raise_error(TypeError)
+  end
+
+  it 'should raise error if the repeat operation is given arguments of incorrect type (2)' do
+    lambda do 
+      @variables.must.match @model.repeat(@value1, [0], 1)
+    end.should raise_error(TypeError)
+  end
+
+  it 'should raise error if the repeat operation is given arguments of incorrect type (3)' do
+    lambda do 
+      @variables.must.match @model.repeat(@value1, 0, [1])
+    end.should raise_error(TypeError)
+  end
+  
+  it 'should raise error if the repeat operation is given arguments of incorrect type' do
+    lambda do 
+      @variables.must.match @model.repeat('foo', 0, 1)
+    end.should raise_error(TypeError)
+  end
+
+  it 'should not allow negation' do
+    lambda do 
+      @variables.must_not.match @regexp
+    end.should raise_error(Gecode::MissingConstraintError)
+  end
+
+  it_should_behave_like 'non-reifiable constraint'
+end
+
+describe Gecode::Constraints::IntEnum::Extensional, ' (regexp constraint)' do
+  before do
+    @model = Gecode::Model.new
+    @variables = @digits = @model.int_var_array(3, 0..9)
+    @model.branch_on @digits
+    @expected_array = an_instance_of Gecode::Raw::IntVarArray
+    @value1 = 3
+    @value2 = 5
+    @regexp = [1, @model.any(3, 4), @model.at_most_once(5)]
+  end
+
+  it 'should handle the any operation' do
+    @digits.must.match [1, @model.any(1, 2, 3), 3]
+    @model.solve!.should_not be_nil
+    values = @digits.values
+    values.size.should == 3 
+    values.should == values.sort
+  end
+
+  it 'should handle the any operator with nested expressions' do
+    @digits.must.match [1, @model.any(@model.at_least_once(2), [3, 5])]
+    @digits[2].must < 4
+    @model.solve!.should_not be_nil
+    @digits.values.should == [1,2,2]
+  end
+
+  it_should_behave_like 'regular expression constraint'
+end
+
+describe Gecode::Constraints::BoolEnum::Extensional, ' (regexp constraint)' do
+  before do
+    @model = Gecode::Model.new
+    @variables = @bools = @model.bool_var_array(3)
+    @model.branch_on @bools
+    @expected_array = an_instance_of Gecode::Raw::BoolVarArray
+    @value1 = true
+    @value2 = false
+    @regexp = [true, @model.any(true, false), @model.at_most_once(true)]
+  end
+
+  it 'should handle the any operation' do
+    @bools.must.match [@model.repeat(@model.any(true, false))]
+    @bools[0].must_be.true
+    @bools[1].must_be.false
+    @model.solve!.should_not be_nil
+    @bools[0].value.should be_true
+    @bools[1].value.should be_false
+  end
+
+  it 'should handle the any operator with nested expressions' do
+    @bools.must.match [@model.any(@model.at_least_once(true), [false])]
+    @model.solve!.should_not be_nil
+    @bools.values.should == [true, true, true]
+  end
+
+  it_should_behave_like 'regular expression constraint'
+end

data/specs/constraints/reification_sugar.rb

@@ -26,28 +26,6 @@ describe Gecode::Constraints::ReifiableConstraint do
     @model.solve!.should be_nil
   end
   
-  it 'should translate disjunctions' do
-    Gecode::Raw.should_receive(:rel).once.with(
-      an_instance_of(Gecode::Raw::Space), 
-      an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::BOT_OR, 
-      an_instance_of(Gecode::Raw::BoolVar), 
-      an_instance_of(Gecode::Raw::BoolVar),
-      Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF      
-    )
-    Gecode::Raw.should_receive(:rel).once.with(
-      an_instance_of(Gecode::Raw::Space), 
-      an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_GR, 0, 
-      an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::ICL_DEF,
-      Gecode::Raw::PK_DEF)
-    Gecode::Raw.should_receive(:rel).once.with(
-      an_instance_of(Gecode::Raw::Space), 
-      an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_EQ, 3, 
-      an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::ICL_DEF,
-      Gecode::Raw::PK_DEF)
-    (@x.must > 0) | (@y.must == 3)
-    sol = @model.solve!
-  end
-  
   it 'should solve disjunctions' do
     (@x.must > 0) | (@y.must == 3)
     sol = @model.solve!
@@ -59,29 +37,7 @@ describe Gecode::Constraints::ReifiableConstraint do
     (@x.must > 3) & (@y.must == 3)
     @model.solve!.should be_nil
   end
-  
-  it 'should translate conjunctions' do
-    Gecode::Raw.should_receive(:rel).once.with(
-      an_instance_of(Gecode::Raw::Space), 
-      an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::BOT_AND, 
-      an_instance_of(Gecode::Raw::BoolVar), 
-      an_instance_of(Gecode::Raw::BoolVar),
-      Gecode::Raw::ICL_DEF, Gecode::Raw::PK_DEF      
-    )
-    Gecode::Raw.should_receive(:rel).once.with(
-      an_instance_of(Gecode::Raw::Space), 
-      an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_GR, 0, 
-      an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::ICL_DEF,
-      Gecode::Raw::PK_DEF)
-    Gecode::Raw.should_receive(:rel).once.with(
-      an_instance_of(Gecode::Raw::Space), 
-      an_instance_of(Gecode::Raw::IntVar), Gecode::Raw::IRT_EQ, 2, 
-      an_instance_of(Gecode::Raw::BoolVar), Gecode::Raw::ICL_DEF,
-      Gecode::Raw::PK_DEF)
-    (@x.must > 0) & (@y.must == 2)
-    sol = @model.solve!
-  end
-  
+
   it 'should solve conjunctions' do
     (@x.must > 0) & (@y.must == 2)
     sol = @model.solve!
@@ -111,4 +67,4 @@ describe Gecode::Constraints::ReifiableConstraint do
     sol = @model.solve!
     sol.should be_nil
   end
-end
+end

data/specs/model.rb

@@ -9,7 +9,7 @@ describe Gecode::Model, ' (integer creation)' do
     range = 0..3
     @model.int_var(range).should have_domain(range)
   end
-  
+
   it 'should allow the creation of int variables without specified domain' do
     var = @model.int_var
     var.should be_range
@@ -43,6 +43,17 @@ describe Gecode::Model, ' (integer creation)' do
     vars.each{ |var| var.should have_domain(domain) }
   end
   
+  it 'should allow the creation of int-var arrays without specified domain' do
+    count = 5
+    vars = @model.int_var_array(count)
+    vars.size.should equal(count)
+    vars.each do |var|
+      var.should be_range
+      var.min.should == Gecode::Raw::IntLimits::MIN
+      var.max.should == Gecode::Raw::IntLimits::MAX
+    end
+  end
+  
   it 'should allow the creation of int-var matrices with range domains' do
     range = 0..3
     rows = 5
@@ -62,6 +73,32 @@ describe Gecode::Model, ' (integer creation)' do
     vars.column_size.should equal(columns)
     vars.each{ |var| var.should have_domain(domain) }
   end
+  
+  it 'should allow the creation of int-var matrices without specified domain' do
+    rows = 5
+    columns = 4
+    vars = @model.int_var_matrix(rows, columns)
+    vars.row_size.should equal(rows)
+    vars.column_size.should equal(columns)
+    vars.each do |var|
+      var.should be_range
+      var.min.should == Gecode::Raw::IntLimits::MIN
+      var.max.should == Gecode::Raw::IntLimits::MAX
+    end
+  end
+  
+  it 'should raise error if the domain is of incorrect type' do
+    lambda do 
+      @model.int_var(nil)
+    end.should raise_error(TypeError) 
+  end
+  
+  it 'should gracefully GC a variable that was never accessed' do
+    lambda do
+      @model.int_var 0
+      GC.start
+    end.should_not raise_error
+  end
 end
 
 describe Gecode::Model, ' (bool creation)' do
@@ -82,6 +119,13 @@ describe Gecode::Model, ' (bool creation)' do
     matrix.row_size.should equal(3)
     matrix.column_size.should equal(4)
   end
+  
+  it 'should gracefully GC a variable that was never accessed' do
+    lambda do
+      @model.bool_var
+      GC.start
+    end.should_not raise_error
+  end
 end
 
 describe Gecode::Model, ' (set creation)' do
@@ -143,6 +187,15 @@ describe Gecode::Model, ' (set creation)' do
     end
   end
   
+  it 'should allow the creation of arrays of set variables without specified bounds' do
+    vars = @model.set_var_array(3)
+    vars.each do |var|
+      var.lower_bound.size.should == 0
+      var.upper_bound.min.should == Gecode::Raw::SetLimits::MIN
+      var.upper_bound.max.should == Gecode::Raw::SetLimits::MAX
+    end
+  end
+  
   it 'should allow the creation of matrices of set variables' do
     matrix = @model.set_var_matrix(4, 5, @glb_enum, @lub_enum, 
       @lower_card..@upper_card)
@@ -154,20 +207,45 @@ describe Gecode::Model, ' (set creation)' do
       var.cardinality.begin.should >= @lower_card
     end
   end
+
+  it 'should allow the creation of matrices of set variables without specified bounds' do
+    matrix = @model.set_var_matrix(4, 5)
+    matrix.each do |var|
+      var.lower_bound.size.should == 0
+      var.upper_bound.min.should == Gecode::Raw::SetLimits::MIN
+      var.upper_bound.max.should == Gecode::Raw::SetLimits::MAX
+    end
+  end
   
   it 'should raise error if glb and lub are not valid when they are given as range' do
-    lambda{ @model.set_var(@lub_range, @glb_range).should }.should raise_error(
-      ArgumentError)  
+    lambda do 
+      @model.set_var(@lub_range, @glb_range)
+    end.should raise_error(ArgumentError)  
   end
   
   it 'should raise error if glb and lub are not valid when one is given as enum' do
-    lambda{ @model.set_var(@lub_range, @glb_enum).should }.should raise_error(
-      ArgumentError)
+    lambda do
+      @model.set_var(@lub_range, @glb_enum)
+    end.should raise_error(ArgumentError)
   end
   
   it 'should raise error if glb and lub are not valid when both are given as enums' do
-    lambda{ @model.set_var(@lub_enum, @glb_enum).should }.should raise_error(
-      ArgumentError)  
+    lambda do
+      @model.set_var(@lub_enum, @glb_enum)
+    end.should raise_error(ArgumentError)  
+  end
+  
+  it 'should raise error if the glb and lub are of incorrect type' do
+    lambda do 
+      @model.set_var("foo\n", "foo\ns")
+    end.should raise_error(TypeError) 
+  end
+
+  it 'should gracefully GC a variable that was never accessed' do
+    lambda do
+      @model.set_var(@glb_range, @lub_range)
+      GC.start
+    end.should_not raise_error
   end
 end
 

data/tasks/dependencies.txt

@@ -9,6 +9,7 @@ coderay
 
 # To run the specs and produce a report for the website.
 rspec
+rcov
 
 # To release files to RubyForge.
 meta_project

data/vendor/rust/rust/class.rb

@@ -260,7 +260,7 @@ module Rust
       
       private
       def raw_call(nparam = nil)
-        case @position
+        case position(@parameters.size)
           when 1 # pre
             "#{@name} (*tmp)"
           when 2 # mid
@@ -272,43 +272,41 @@ module Rust
         end
       end
       
+      # 1: pre 2: mid 3: post 4: mixed
+      def position(nparam)
+        case @name
+          when "+": (nparam.zero? ? 1 : 3)
+          when "-": 3
+          when "*": (nparam.zero? ? 1 : 3)
+          when "/": 3
+          when /\[\s*\]=/: 4
+          when /\[\s*\]/: 2
+          when "==": 3
+          when "!=": 3
+          when "<<": 3
+          when ">>": 3
+          when "!": 1
+          when "()": 2
+          else
+            3
+        end
+      end
+      
       def valid_name
         case @name
-          when "+"
-            @position = 3
-            "plusop"
-          when "-"
-            @position = 3
-            "minusop"
-          when "*"
-            @position = 3
-            "multop"
-          when "/"
-            @position = 3
-            "divop"
-          when /\[\s*\]=/
-            @position = 4
-            "ateqop"
-          when /\[\s*\]/
-            @position = 2
-            "atop"
-          when "=="
-            @position = 3
-            "equalop"
-          when "!="
-            @position = 3
-            "notequalop"
-          when "<<"
-            @position = 3
-            "outstream"
-          when ">>"
-            @position = 3
-            "intstream"
-          when "!"
-            @position = 1
-            "notop"
+          when "+": "plusop"
+          when "-": "minusop"
+          when "*": "multop"
+          when "/": "divop"
+          when /\[\s*\]=/: "ateqop"
+          when /\[\s*\]/: "atop"
+          when "==": "equalop"
+          when "!=": "notequalop"
+          when "<<": "outstream"
+          when ">>": "intstream"
+          when "!": "notop"
+          when "()": "parenthesisop"
           else
-            @position = 3
             "undefop_#{@name[0].chr.to_i}#{rand(1024)}"
         end
       end

data/vendor/rust/rust/templates/ClassDeclarations.rusttpl

@@ -1,7 +1,7 @@
 //-*-c++-*-
 
 extern VALUE r!class_varname!;
-VALUE cxx2ruby(!c_class_name!* instance, bool free = false);
+VALUE cxx2ruby(!c_class_name!* instance, bool free = false, bool create_new_if_needed = true);
 bool is_!class_varname!(VALUE val);
 !c_class_name!* ruby2!class_varcname!Ptr(VALUE rval, int argn = -1);
 !c_class_name!& ruby2!class_varcname!(VALUE rval, int argn = -1);

data/vendor/rust/rust/templates/CxxClassDefinitions.rusttpl

@@ -51,17 +51,26 @@ bool is_!class_varname!(VALUE val)
   return *ruby2!class_varcname!Ptr(rval, argn);
 }
 
-VALUE cxx2ruby(!c_class_name!* instance, bool free) {
+VALUE cxx2ruby(!c_class_name!* instance, bool free, bool create_new_if_needed) {
   if ( instance == NULL ) return Qnil;
 
   T!class_ptrmap!::iterator it, eend = !class_ptrmap!.end();
 
+#ifdef DEBUG      
+  fprintf(stderr, "rust: searching for !c_class_name! %p\n", instance);
+#endif
+
   for(it = !class_ptrmap!.begin(); it != eend; it++)
      if ( (*it).second == (!c_class_name!*)instance ) break;
 
    if ( it != !class_ptrmap!.end() )
       return (*it).first;
    else {
+#ifdef DEBUG      
+      fprintf(stderr, "rust: failed to find match for %p\n", instance);
+#endif
+      if(!create_new_if_needed) return Qnil;
+   
       VALUE klass = r!class_varname!;
 
 !test_children!