gecoder-with-gecode 0.9.0-x86-mswin32-60

data/lib/gecoder/version.rb

@@ -0,0 +1,4 @@
+module GecodeR #:nodoc:
+  # A string representation of the Gecode/R version.
+  VERSION = '0.9.0'
+end

data/specs/bool_var.rb

@@ -0,0 +1,81 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/constraints/property_helper'
+
+describe 'non-empty bool variable', :shared => true do
+  it 'should give a NoMethodError when calling a method that doesn\'t exist' do
+    lambda{ @var.this_method_does_not_exists }.should raise_error(NoMethodError)
+  end
+end
+
+describe Gecode::BoolVar, '(not assigned)' do
+  before do
+    @model = Gecode::Model.new
+    @operand = @var = @model.bool_var
+  end
+  
+  it_should_behave_like 'non-empty bool variable'
+  
+  it 'should not be assigned' do
+    @var.should_not be_assigned
+  end
+  
+  it "should say that it's not assigned when inspecting" do
+    @var.inspect.should include('unassigned')
+  end
+  
+  it 'should raise error when trying to access assigned value' do
+    lambda{ @var.value }.should raise_error(RuntimeError)
+  end
+
+  it_should_behave_like 'bool var operand'
+end
+
+describe Gecode::BoolVar, '(assigned true)' do
+  before do
+    @model = Gecode::Model.new
+    @operand = @var = @model.bool_var
+    @var.must_be.true
+    @model.solve!
+  end
+  
+  it_should_behave_like 'non-empty bool variable'
+  
+  it 'should be assigned' do
+    @var.should be_assigned
+  end
+  
+  it 'should have valye true' do
+    @var.value.should be_true
+  end
+  
+  it "should say that it's true when inspecting" do
+    @var.inspect.should include('true')
+  end
+  
+  it_should_behave_like 'bool var operand'
+end
+
+describe Gecode::BoolVar, '(assigned false)' do
+  before do
+    @model = Gecode::Model.new
+    @operand = @var = @model.bool_var
+    @var.must_be.false
+    @model.solve!
+  end
+  
+  it_should_behave_like 'non-empty bool variable'
+  
+  it 'should be assigned' do
+    @var.should be_assigned
+  end
+  
+  it 'should have value false ' do
+    @var.value.should_not be_true
+  end
+  
+  it "should say that it's false when inspecting" do
+    @var.inspect.should include('false')
+  end
+
+  it_should_behave_like 'bool var operand'
+end

data/specs/branch.rb

@@ -0,0 +1,185 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class BranchSampleProblem < Gecode::Model
+  attr :vars
+  attr :bools
+  attr :sets
+  
+  def initialize
+    @vars = int_var_array(2, 0..3)
+    @sets = set_var_array(2, [], 0..4)
+    @bools = bool_var_array(2)
+  end
+end
+
+describe Gecode::Model, ' (integer branch)' do
+  before do
+    @model = BranchSampleProblem.new
+    @vars = @model.vars
+    @bools = @model.bools
+  end
+
+  it 'should default to :none and :min' do
+    Gecode::Raw.should_receive(:branch).once.with(
+      an_instance_of(Gecode::Raw::Space), 
+      anything, Gecode::Raw::INT_VAR_NONE, Gecode::Raw::INT_VAL_MIN)
+    @model.branch_on @vars
+    @model.solve!
+  end
+  
+  it 'should ensure that branched int variables are assigned in a solution' do
+    @model.branch_on @vars
+    @model.solve!.vars.each{ |var| var.should be_assigned }
+  end
+  
+  it 'should ensure that branched bool variables are assigned in a solution' do
+    @model.branch_on @bools
+    @model.solve!.bools.each{ |var| var.should be_assigned }
+  end
+
+  it 'should allow branching on a single integer variable' do
+    @model.branch_on @vars.first
+    @model.solve!.vars.first.should be_assigned
+  end
+
+  it 'should allow branching on a single boolean variable' do
+    @model.branch_on @bools.first
+    @model.solve!.bools.first.should be_assigned
+  end
+
+  supported_var_selectors = {
+    :none                 => Gecode::Raw::INT_VAR_NONE,
+    :smallest_min         => Gecode::Raw::INT_VAR_MIN_MIN,
+    :largest_min          => Gecode::Raw::INT_VAR_MIN_MAX, 
+    :smallest_max         => Gecode::Raw::INT_VAR_MAX_MIN, 
+    :largest_max          => Gecode::Raw::INT_VAR_MAX_MAX, 
+    :smallest_size        => Gecode::Raw::INT_VAR_SIZE_MIN, 
+    :largest_size         => Gecode::Raw::INT_VAR_SIZE_MAX,
+    :smallest_degree      => Gecode::Raw::INT_VAR_DEGREE_MIN, 
+    :largest_degree       => Gecode::Raw::INT_VAR_DEGREE_MAX, 
+    :smallest_min_regret  => Gecode::Raw::INT_VAR_REGRET_MIN_MIN,
+    :largest_min_regret   => Gecode::Raw::INT_VAR_REGRET_MIN_MAX,
+    :smallest_max_regret  => Gecode::Raw::INT_VAR_REGRET_MAX_MIN, 
+    :largest_max_regret   => Gecode::Raw::INT_VAR_REGRET_MAX_MAX
+  }.each_pair do |name, gecode_const|
+    it "should support #{name} as variable selection strategy" do
+      Gecode::Raw.should_receive(:branch).once.with(
+        an_instance_of(Gecode::Raw::Space),
+        anything, gecode_const, an_instance_of(Numeric))
+      @model.branch_on @vars, :variable => name
+      @model.solve!
+    end
+  end
+
+  supported_val_selectors = {
+    :min        => Gecode::Raw::INT_VAL_MIN,
+    :med        => Gecode::Raw::INT_VAL_MED,
+    :max        => Gecode::Raw::INT_VAL_MAX,
+    :split_min  => Gecode::Raw::INT_VAL_SPLIT_MIN,
+    :split_max  => Gecode::Raw::INT_VAL_SPLIT_MAX
+  }.each_pair do |name, gecode_const|
+    it "should support #{name} as value selection strategy" do
+      Gecode::Raw.should_receive(:branch).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        anything, an_instance_of(Numeric), gecode_const)
+      @model.branch_on @vars, :value => name
+      @model.solve!
+    end
+  end
+
+  it 'should raise errors for unrecognized var selection strategies' do
+    lambda do 
+      @model.branch_on @vars, :variable => :foo 
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should raise errors for unrecognized val selection strategies' do
+    lambda do 
+      @model.branch_on @vars, :value => :foo 
+    end.should raise_error(ArgumentError)
+  end
+
+  it 'should raise errors for unrecognized options' do
+    lambda do
+      @model.branch_on @vars, :foo => 5 
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should raise errors for unrecognized enumerations' do
+    lambda do
+      @model.branch_on [1,2,3]
+    end.should raise_error(TypeError)
+  end
+end
+
+describe Gecode::Model, ' (set branch)' do
+  before do
+    @model = BranchSampleProblem.new
+    @sets = @model.sets
+  end
+
+  it 'should default to :none and :min' do
+    Gecode::Raw.should_receive(:branch).once.with(
+      an_instance_of(Gecode::Raw::Space), 
+      anything, Gecode::Raw::SET_VAR_NONE, Gecode::Raw::SET_VAL_MIN)
+    @model.branch_on @sets
+    @model.solve!
+  end
+  
+  it 'should ensure that branched set variables are assigned in a solution' do
+    @model.branch_on @sets
+    @model.solve!.sets.each{ |var| var.should be_assigned }
+  end
+  
+  it 'should allow branching on a single set variable' do
+    @model.branch_on @sets.first
+    @model.solve!.sets.first.should be_assigned
+  end
+
+  supported_var_selectors = {
+    :none                 => Gecode::Raw::SET_VAR_NONE,
+    :smallest_cardinality => Gecode::Raw::SET_VAR_MIN_CARD,
+    :largest_cardinality  => Gecode::Raw::SET_VAR_MAX_CARD, 
+    :smallest_unknown     => Gecode::Raw::SET_VAR_MIN_UNKNOWN_ELEM, 
+    :largest_unknown      => Gecode::Raw::SET_VAR_MAX_UNKNOWN_ELEM
+  }.each_pair do |name, gecode_const|
+    it "should support #{name} as variable selection strategy" do
+      Gecode::Raw.should_receive(:branch).once.with(
+        an_instance_of(Gecode::Raw::Space),
+        anything, gecode_const, an_instance_of(Numeric))
+      @model.branch_on @sets, :variable => name
+      @model.solve!
+    end
+  end
+
+  supported_val_selectors = {
+    :min  => Gecode::Raw::SET_VAL_MIN,
+    :max  => Gecode::Raw::SET_VAL_MAX
+  }.each_pair do |name, gecode_const|
+    it "should support #{name} as value selection strategy" do
+      Gecode::Raw.should_receive(:branch).once.with(
+        an_instance_of(Gecode::Raw::Space), 
+        anything, an_instance_of(Numeric), gecode_const)
+      @model.branch_on @sets, :value => name
+      @model.solve!
+    end
+  end
+
+  it 'should raise errors for unrecognized var selection strategies' do
+    lambda do 
+      @model.branch_on @sets, :variable => :foo 
+    end.should raise_error(ArgumentError)
+  end
+  
+  it 'should raise errors for unrecognized val selection strategies' do
+    lambda do 
+      @model.branch_on @sets, :value => :foo 
+    end.should raise_error(ArgumentError)
+  end
+
+  it 'should raise errors for unrecognized options' do
+    lambda do
+      @model.branch_on @sets, :foo => 5 
+    end.should raise_error(ArgumentError)
+  end
+end

data/specs/constraints/bool/boolean.rb

@@ -0,0 +1,317 @@
+require File.dirname(__FILE__) + '/../constraint_helper'
+
+class BoolSampleProblem < Gecode::Model
+  attr :b1
+  attr :b2
+  attr :b3
+  
+  def initialize
+    @b1 = self.bool_var
+    @b2 = self.bool_var
+    @b3 = self.bool_var
+  end
+end
+
+[:true, :false].each do |type|
+  describe Gecode::Bool, " (must be #{type})" do
+    before do
+      @model = Gecode::Model.new
+      @bool = @model.bool_var
+
+      @types = [:bool]
+      @invoke = lambda do |receiver, hash| 
+        receiver.method(type).call(hash) 
+        @model.solve!
+      end
+      @expect = lambda do |var, opts, reif_var|
+        # We only test the non-MiniModel parts.
+        unless reif_var.nil?
+          Gecode::Raw.should_receive(:rel).once.with(
+            an_instance_of(Gecode::Raw::Space), 
+            an_instance_of(Gecode::Raw::BoolVar), 
+            (type == :true) ? Gecode::Raw::IRT_EQ : Gecode::Raw::IRT_NQ,
+            reif_var, *opts)
+        end
+      end
+    end
+
+    it "should constrain variables to be #{type}" do
+      @bool.must.method(type).call
+      @model.solve!
+      @bool.value.should == (type == :true)
+    end
+    
+    it "should make negation constrain variables to not be #{type}" do
+      @bool.must_not.method(type).call
+      @model.solve!
+      @bool.value.should == (type != :true)
+    end  
+
+    it_should_behave_like 'reifiable constraint'
+  end
+end
+
+describe Gecode::Bool, " (implies)" do
+  before do
+    @model = Gecode::Model.new
+    @b1 = @model.bool_var
+    @b2 = @model.bool_var
+    @model.branch_on @model.wrap_enum([@b1, @b2])
+
+    @types = [:bool, :bool]
+    @invoke = lambda do |receiver, op, hash| 
+      receiver.imply(op, hash) 
+      @model.solve!
+    end
+    @expect = lambda do |var1, var2, opts, reif_var|
+    end
+  end
+
+  it "should constrain variables to imply each other" do
+    @b1.must.imply @b2
+    @model.solve!
+    (!@b1.value || @b2.value).should be_true
+  end
+  
+  it "should, when negated, constrain variables to not imply each other" do
+    @b1.must_not.imply @b2
+    @model.solve!
+    @b1.value.should be_true
+    @b2.value.should_not be_true
+  end  
+
+  it_should_behave_like 'reifiable constraint'
+end
+
+describe Gecode::Bool, " (equality)" do
+  before do
+    @model = Gecode::Model.new
+    @b1 = @model.bool_var
+    @b2 = @model.bool_var
+    @model.branch_on @model.wrap_enum([@b1, @b2])
+
+    @types = [:bool, :bool]
+    @invoke = lambda do |receiver, op, hash| 
+      receiver.equal(op, hash) 
+      @model.solve!
+    end
+    @expect = lambda do |var1, var2, opts, reif_var|
+    end
+  end
+
+  it "should constrain variables to equal each other" do
+    @b1.must == @b2
+    @model.solve!
+    @b1.value.should == @b2.value
+  end
+  
+  it "should, when negated, constrain variables to not equal each other" do
+    @b1.must_not == @b2
+    @model.solve!
+    @b1.value.should_not == @b2.value
+  end  
+
+  it_should_behave_like 'reifiable constraint'
+end
+
+describe Gecode::Bool do
+  before do
+    @model = BoolSampleProblem.new
+    @b1 = @model.b1
+    @b2 = @model.b2
+    @b3 = @model.b3
+  end
+
+  it 'should handle single variables constrainted to be true' do
+    @b1.must_be.true
+    b1 = @model.solve!.b1
+    b1.should be_assigned
+    b1.value.should be_true
+  end
+  
+  it 'should handle single variables constrainted to be false' do
+    @b1.must_be.false
+    b1 = @model.solve!.b1
+    b1.should be_assigned
+    b1.value.should_not be_true
+  end
+  
+  it 'should handle single variables constrainted not to be false' do
+    @b1.must_not_be.false
+    b1 = @model.solve!.b1
+    b1.should be_assigned
+    b1.value.should be_true
+  end
+  
+  it 'should handle single variables constrainted not to be true' do
+    @b1.must_not_be.true
+    b1 = @model.solve!.b1
+    b1.should be_assigned
+    b1.value.should_not be_true
+  end
+
+  it 'should handle disjunction' do
+    @b1.must_be.false
+    (@b1 | @b2).must_be.true
+    sol = @model.solve!
+    sol.b1.value.should_not be_true
+    sol.b2.value.should be_true
+  end
+
+  it 'should handle negated disjunction' do
+    @b1.must_be.false
+    (@b1 | @b2).must_not_be.true
+    sol = @model.solve!
+    sol.b1.value.should_not be_true
+    sol.b2.value.should_not be_true
+  end
+
+  it 'should handle conjunction' do
+    (@b1 & @b2).must_be.true
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should be_true
+  end
+
+  it 'should handle negated conjunction' do
+    @b1.must_be.true
+    (@b1 & @b2).must_not_be.true
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should_not be_true
+  end
+
+  it 'should handle exclusive or' do
+    @b1.must_be.false
+    (@b1 ^ @b2).must_be.true
+    sol = @model.solve!
+    sol.b1.value.should_not be_true
+    sol.b2.value.should be_true
+  end
+
+  it 'should handle negated exclusive or' do
+    @b1.must_be.true
+    (@b1 ^ @b2).must_not_be.true
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should be_true
+  end
+  
+  it 'should handle implication' do
+    @b2.must_be.false
+    (@b1.implies @b2).must_be.true
+    sol = @model.solve!
+    sol.b1.value.should_not be_true
+    sol.b2.value.should_not be_true
+  end
+  
+  it 'should handle negated implication' do
+    @b1.must_be.true
+    ((@b1 | @b2).implies @b2).must_not_be.true
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should_not be_true
+  end
+  
+  it 'should handle imply after must' do
+    @b2.must_be.false
+    @b1.must.imply @b2
+    sol = @model.solve!
+    sol.b1.value.should_not be_true
+    sol.b2.value.should_not be_true
+  end
+
+  it 'should handle imply after must_not' do
+    @b1.must_be.true
+    @b1.must_not.imply @b2
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should_not be_true
+  end
+
+  it 'should handle single variables as right hand side' do
+    @b1.must == @b2
+    @b2.must_be.false
+    sol = @model.solve!
+    sol.b1.value.should_not be_true
+    sol.b2.value.should_not be_true
+  end
+  
+  it 'should handle single variables with negation as right hand side' do
+    @b1.must_not == @b2
+    @b2.must_be.false
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should_not be_true
+  end
+
+  it 'should handle expressions as right hand side' do
+    @b1.must == (@b2 | @b3)
+    @b2.must_be.true
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should be_true
+  end
+
+  it 'should handle nested expressions as left hand side' do
+    ((@b1 & @b2) | @b3 | (@b1 & @b3)).must_be.true
+    @b1.must_be.false
+    sol = @model.solve!
+    sol.b1.value.should_not be_true
+    sol.b3.value.should be_true
+  end
+
+  it 'should handle nested expressions on both side' do
+    ((@b1 & @b1) | @b3).must == ((@b1 & @b3) & @b2)
+    @b1.must_be.true
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should be_true
+    sol.b3.value.should be_true
+  end
+
+  it 'should handle nested expressions with implication' do
+    ((@b1 & @b1) | @b3).must.imply(@b1 ^ @b2)
+    @b1.must_be.true
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should be_false
+  end
+
+  it 'should handle nested expressions containing exclusive or' do
+    ((@b1 ^ @b1) & @b3).must == ((@b2 | @b3) ^ @b2)
+    @b1.must_be.true
+    @b2.must_be.false
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should_not be_true
+    sol.b3.value.should_not be_true
+  end
+
+  it 'should handle nested expressions on both sides with negation' do
+    ((@b1 & @b1) | @b3).must_not == ((@b1 | @b3) & @b2)
+    @b1.must_be.true
+    @b3.must_be.true
+    sol = @model.solve!
+    sol.b1.value.should be_true
+    sol.b2.value.should_not be_true
+    sol.b3.value.should be_true
+  end
+
+  it 'should translate reification with a variable right hand side' do
+    @b1.must_be.equal_to(@b2, :reify => @b3)
+    @b1.must_be.true
+    @b2.must_be.false
+    sol = @model.solve!
+    sol.b3.value.should_not be_true
+  end
+
+  it 'should translate reification with a variable right hand side and negation'  do
+    @b1.must_not_be.equal_to(@b2, :reify => @b3)
+    @b1.must_be.true
+    @b2.must_be.false
+    sol = @model.solve!
+    sol.b3.value.should be_true
+  end
+end
+