gecoder 0.5.0 → 0.6.0

data/lib/gecoder/interface/constraints.rb

@@ -339,3 +339,4 @@ require 'gecoder/interface/constraints/int_enum_constraints'
 require 'gecoder/interface/constraints/bool_var_constraints'
 require 'gecoder/interface/constraints/bool_enum_constraints'
 require 'gecoder/interface/constraints/set_var_constraints'
+require 'gecoder/interface/constraints/set_enum_constraints'

data/lib/gecoder/interface/constraints/bool_enum/boolean.rb

@@ -25,13 +25,15 @@ module Gecode
           variable = @model.bool_var
         end
         
-        if variable.respond_to? :bind
-          bound = variable.bind
-        else
-          bound = variable
+        @model.add_interaction do
+          if variable.respond_to? :bind
+            bound = variable.bind
+          else
+            bound = variable
+          end
+          Gecode::Raw::bool_and(@model.active_space, enum.to_bool_var_array, 
+            bound, strength)
         end
-        Gecode::Raw::bool_and(@model.active_space, enum.to_bool_var_array, 
-          bound, strength)
         return variable
       end
     end
@@ -45,13 +47,15 @@ module Gecode
           variable = @model.bool_var
         end
         
-        if variable.respond_to? :bind
-          bound = variable.bind
-        else
-          bound = variable
+        @model.add_interaction do
+          if variable.respond_to? :bind
+            bound = variable.bind
+          else
+            bound = variable
+          end
+          Gecode::Raw::bool_or(@model.active_space, enum.to_bool_var_array, 
+            bound, strength)
         end
-        Gecode::Raw::bool_or(@model.active_space, enum.to_bool_var_array, 
-          bound, strength)
         return variable
       end
     end

data/lib/gecoder/interface/constraints/int/arithmetic.rb

@@ -29,7 +29,9 @@ module Gecode::Constraints::Int::Arithmetic
         variable = @model.int_var(lhs.min..lhs.max)
       end
       
-      Gecode::Raw::abs(@model.active_space, lhs.bind, variable.bind, strength)
+      @model.add_interaction do
+        Gecode::Raw::abs(@model.active_space, lhs.bind, variable.bind, strength)
+      end
       return variable
     end
   end
@@ -46,8 +48,10 @@ module Gecode::Constraints::Int::Arithmetic
         variable = @model.int_var(products.min..products.max)
       end
 
-      Gecode::Raw::mult(@model.active_space, lhs.bind, lhs2.bind, 
-        variable.bind, strength)
+      @model.add_interaction do
+        Gecode::Raw::mult(@model.active_space, lhs.bind, lhs2.bind, 
+          variable.bind, strength)
+      end
       return variable
     end
   end

data/lib/gecoder/interface/constraints/int/linear.rb

@@ -85,11 +85,9 @@ module Gecode
         if lhs.kind_of? Gecode::FreeIntVar
           lhs = lhs * 1 # Convert to Gecode::Raw::LinExp
         end
-        if right_hand_side.respond_to? :to_minimodel_lin_exp
-          right_hand_side = right_hand_side.to_minimodel_lin_exp
-        elsif right_hand_side.kind_of? Gecode::FreeIntVar
-          right_hand_side = right_hand_side.bind * 1
-        elsif not right_hand_side.kind_of? Fixnum
+        if not (right_hand_side.respond_to? :to_minimodel_lin_exp or
+            right_hand_side.kind_of? Gecode::FreeIntVar or 
+            right_hand_side.kind_of? Fixnum)
           raise TypeError, 'Invalid right hand side of linear equation.'
         end
         
@@ -102,12 +100,6 @@ module Gecode
       # relation type (as specified by Gecode) in relation to the specifed 
       # element.
       def add_relation_constraint(relation_type, element)
-        # Bind parameters.
-        @params[:lhs] = @params[:lhs].bind
-        if element.kind_of? FreeIntVar
-          element = element.bind
-        end
-      
         @model.add_constraint Linear::SimpleRelationConstraint.new(@model, 
           @params.update(:relation_type => relation_type, :element => element))
       end
@@ -122,6 +114,11 @@ module Gecode
         lhs, rhs, relation_type, reif_var, strength = @params.values_at(:lhs, 
           :rhs, :relation_type, :reif, :strength)
         reif_var = reif_var.bind if reif_var.respond_to? :bind
+        if rhs.respond_to? :to_minimodel_lin_exp
+          rhs = rhs.to_minimodel_lin_exp
+        elsif rhs.kind_of? Gecode::FreeIntVar
+          rhs = rhs.bind * 1
+        end
 
         final_exp = (lhs.to_minimodel_lin_exp - rhs)
         if reif_var.nil?
@@ -136,11 +133,17 @@ module Gecode
     class SimpleRelationConstraint < Gecode::Constraints::ReifiableConstraint
       def post        
         # Fetch the parameters to Gecode.
-        params = @params.values_at(:lhs, :relation_type, :element, :reif, 
-          :strength)
-        params[3] = params[3].bind unless params[3].nil? # Bind reification var.
-        params.delete_if{ |x| x.nil? }
-        Gecode::Raw::rel(@model.active_space, *params)
+        lhs, relation, rhs, reif_var, strength = @params.values_at(:lhs, 
+          :relation_type, :element, :reif, :strength)
+          
+        rhs = rhs.bind if rhs.respond_to? :bind
+        if reif_var.nil?
+          Gecode::Raw::rel(@model.active_space, lhs.bind, relation, rhs, 
+            strength)
+        else
+          Gecode::Raw::rel(@model.active_space, lhs.bind, relation, rhs, 
+            reif_var.bind, strength)
+        end
       end
     end
   

data/lib/gecoder/interface/constraints/int_enum/arithmetic.rb

@@ -24,8 +24,10 @@ module Gecode::Constraints::IntEnum::Arithmetic
         variable = @model.int_var(enum.domain_range)
       end
       
-      Gecode::Raw::max(@model.active_space, enum.to_int_var_array, 
-        variable.bind, strength)
+      @model.add_interaction do
+        Gecode::Raw::max(@model.active_space, enum.to_int_var_array, 
+          variable.bind, strength)
+      end
       return variable
     end
   end
@@ -38,8 +40,10 @@ module Gecode::Constraints::IntEnum::Arithmetic
         variable = @model.int_var(enum.domain_range)
       end
       
-      Gecode::Raw::min(@model.active_space, enum.to_int_var_array, 
-        variable.bind, strength)
+      @model.add_interaction do
+        Gecode::Raw::min(@model.active_space, enum.to_int_var_array, 
+          variable.bind, strength)
+      end
       return variable
     end
   end

data/lib/gecoder/interface/constraints/int_enum/channel.rb

@@ -1,13 +1,17 @@
 module Gecode::Constraints::IntEnum
   class Expression
     # Posts a channel constraint on the variables in the enum with the specified
-    # other enum.
+    # other set or int enum.
     def channel(enum, options = {})
       if @params[:negate]
         raise Gecode::MissingConstraintError, 'A negated channel constraint ' + 
           'is not implemented.'
       end
-    
+      unless enum.respond_to?(:to_int_var_array) or 
+          enum.respond_to?(:to_set_var_array)
+        raise TypeError, "Expected int or set enum, got #{enum.class}."
+      end
+      
       @params.update(Gecode::Constraints::Util.decode_options(options))
       @params.update(:rhs => enum)
       @model.add_constraint Channel::ChannelConstraint.new(@model, @params)
@@ -21,11 +25,15 @@ module Gecode::Constraints::IntEnum
       def post
         lhs, rhs, strength = @params.values_at(:lhs, :rhs, :strength)
       
-        # Bind both sides.
         lhs = lhs.to_int_var_array
-        rhs = rhs.to_int_var_array
-        
-        Gecode::Raw::channel(@model.active_space, lhs, rhs, strength)
+        if rhs.respond_to? :to_int_var_array
+          # Int var array.
+          Gecode::Raw::channel(@model.active_space, lhs, rhs.to_int_var_array,
+            strength)
+        else
+          # Set var array, no strength.
+          Gecode::Raw::channel(@model.active_space, lhs, rhs.to_set_var_array)
+        end
       end
     end
   end

data/lib/gecoder/interface/constraints/int_enum/element.rb

@@ -8,11 +8,13 @@ module Gecode::Constraints::IntEnum::Element
       if variable.nil?
         variable = @model.int_var(enum.domain_range)
       end
-      
-      # The enum can be a constant array.
-      enum = enum.to_int_var_array if enum.respond_to? :to_int_var_array
-      Gecode::Raw::element(@model.active_space, enum, 
-        position.bind, variable.bind, strength)
+
+      @model.add_interaction do
+        # The enum can be a constant array.
+        enum = enum.to_int_var_array if enum.respond_to? :to_int_var_array
+        Gecode::Raw::element(@model.active_space, enum, 
+          position.bind, variable.bind, strength)
+      end
       return variable
     end
   end

data/lib/gecoder/interface/constraints/int_enum/sort.rb

@@ -92,10 +92,7 @@ module Gecode::Constraints::IntEnum
           first.must_be.less_than_or_equal_to(second, rel_options)
         end
         if using_reification
-          # TODO use the interface's all constraint when available.
-          # reification_variables.all.must == reif_var
-          Gecode::Raw::bool_and(@model.active_space, 
-            reification_variables.to_bool_var_array, reif_var.bind, strength) 
+          reification_variables.conjunction.must == reif_var
         end
       end
       negate_using_reification

data/lib/gecoder/interface/constraints/set/cardinality.rb

@@ -1,6 +1,6 @@
 module Gecode
   class FreeSetVar
-    # Starts a constraint on all the size of the set.
+    # Starts a constraint on the size of the set.
     def size
       params = {:lhs => self}
       Gecode::Constraints::Set::Cardinality::SizeExpressionStub.new(@model, params)
@@ -46,9 +46,12 @@ module Gecode::Constraints::Set
       def constrain_equal(variable, params)
         lhs = @params[:lhs]
         if variable.nil?
-          variable = @model.int_var(lhs.glb_size, lhs.lub_size)
+          variable = @model.int_var(lhs.lower_bound.size, lhs.upper_bound.size)
+        end
+        
+        @model.add_interaction do 
+          Gecode::Raw::cardinality(@model.active_space, lhs.bind, variable.bind)
         end
-        Gecode::Raw::cardinality(@model.active_space, lhs.bind, variable.bind)
         return variable
       end
     end

data/lib/gecoder/interface/constraints/set/connection.rb

@@ -0,0 +1,136 @@
+module Gecode
+  class FreeSetVar
+    # Starts a constraint on the minimum value of the set.
+    def min
+      params = {:lhs => self}
+      Gecode::Constraints::Set::Connection::MinExpressionStub.new(@model, params)
+    end
+    
+    # Starts a constraint on the maximum value of the set.
+    def max
+      params = {:lhs => self}
+      Gecode::Constraints::Set::Connection::MaxExpressionStub.new(@model, params)
+    end
+    
+    # Starts a constraint on the sum of the set. The option :weights may 
+    # optionally be given with a hash of weights as value. If it is then the 
+    # weighted sum, using the hash as weight function, will be constrained. The
+    # option :substitutions may also be given (with a hash as value), if it is 
+    # then the sum of the set with all elements replaced according to the hash 
+    # is constrained. Elements mapped to nil by the weights or substitutions 
+    # hash are removed from the upper bound of the set. Only one of the two
+    # options may be given at the same time.
+    def sum(options = {:weights => weights = Hash.new(1)})
+      if options.empty? or options.keys.size > 1
+        raise ArgumentError, 'One of the options :weights and :substitutions, ' +
+          'or neither, must be specified.'
+      end
+      params = {:lhs => self}
+      unless options.empty?
+        case options.keys.first
+          when :substitutions: params.update(options)
+          when :weights:
+            weights = options[:weights]
+            substitutions = Hash.new do |hash, key|
+              if weights[key].nil?
+                hash[key] = nil
+              else
+                hash[key] = key * weights[key]
+              end
+            end
+            params.update(:substitutions => substitutions)
+          else raise ArgumentError, "Unrecognized option #{options.keys.first}."
+        end
+      end
+      Gecode::Constraints::Set::Connection::SumExpressionStub.new(@model, params)
+    end
+  end
+end
+
+module Gecode::Constraints::Set
+  class Expression
+    # Adds a constraint that forces specified values to be included in the 
+    # set. This constraint has the side effect of sorting the variables in 
+    # non-descending order.
+    def include(variables)
+      unless variables.respond_to? :to_int_var_array
+        raise TypeError, "Expected int var enum, got #{variables.class}."
+      end
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated include is not ' + 
+          'implemented.'
+      end
+      
+      @params.update(:variables => variables)
+      @model.add_constraint Connection::IncludeConstraint.new(@model, @params)
+    end
+  end
+
+  # A module that gathers the classes and modules used in connection 
+  # constraints.
+  module Connection
+    # Describes an expression stub started with an int var following by #min.
+    class MinExpressionStub < Gecode::Constraints::Int::CompositeStub
+      def constrain_equal(variable, params)
+        set = params[:lhs]
+        if variable.nil?
+          variable = @model.int_var(set.upper_bound.min, set.lower_bound.min)
+        end
+        
+        @model.add_interaction do
+          Gecode::Raw::min(@model.active_space, set.bind, variable.bind)
+        end
+        return variable
+      end
+    end
+    
+    # Describes an expression stub started with an int var following by #max.
+    class MaxExpressionStub < Gecode::Constraints::Int::CompositeStub
+      def constrain_equal(variable, params)
+        set = params[:lhs]
+        if variable.nil?
+          variable = @model.int_var(set.upper_bound.max, set.lower_bound.max)
+        end
+        
+        @model.add_interaction do
+          Gecode::Raw::max(@model.active_space, set.bind, variable.bind)
+        end
+        return variable
+      end
+    end
+    
+    # Describes an expression stub started with an int var following by #max.
+    class SumExpressionStub < Gecode::Constraints::Int::CompositeStub
+      def constrain_equal(variable, params)
+        set, subs = params.values_at(:lhs, :substitutions)
+        lub = set.upper_bound.to_a
+        lub.delete_if{ |e| subs[e].nil? }
+        substituted_lub = lub.map{ |e| subs[e] }
+        if variable.nil?
+          # Compute the theoretical bounds of the weighted sum. This is slightly
+          # sloppy since we could also use the contents of the greatest lower 
+          # bound.
+          min = substituted_lub.find_all{ |e| e < 0}.inject(0){ |x, y| x + y }
+          max = substituted_lub.find_all{ |e| e > 0}.inject(0){ |x, y| x + y }
+          variable = @model.int_var(min..max)
+        end
+
+        @model.add_interaction do
+          Gecode::Raw::weights(@model.active_space, lub, substituted_lub, 
+            set.bind, variable.bind)
+        end
+        return variable
+      end
+    end
+    
+    # Describes a constraint that constrains a set to include a number of 
+    # integer variables.
+    class IncludeConstraint < Gecode::Constraints::Constraint
+      def post
+        set, variables = @params.values_at(:lhs, :variables)
+        Gecode::Raw::match(@model.active_space, set.bind, 
+          variables.to_int_var_array)
+      end
+    end
+  end
+end

data/lib/gecoder/interface/constraints/set_enum/channel.rb

@@ -0,0 +1,18 @@
+module Gecode::Constraints::SetEnum
+  class Expression
+    # Posts a channel constraint on the variables in the enum with the specified
+    # int enum.
+    def channel(enum)
+      unless enum.respond_to? :to_int_var_array
+        raise TypeError, "Expected integer variable enum, for #{enum.class}."
+      end
+      
+      # Just provide commutativity to the corresponding int enum constraint.
+      if @params[:negate]
+        enum.must_not.channel(@params[:lhs])
+      else
+        enum.must.channel(@params[:lhs])
+      end
+    end
+  end
+end

data/lib/gecoder/interface/constraints/set_enum/distinct.rb

@@ -0,0 +1,61 @@
+module Gecode::Constraints::SetEnum
+  class Expression
+    # Adds a distinct constraint on the sets in the enum. The "option" :size 
+    # must be specified, the sets will be constrained to that size.
+    def distinct(options = {})
+      unless options.has_key? :size
+        raise ArgumentError, 'Option :size has to be specified.'
+      end
+      unless options.size == 1
+        raise ArgumentError, 'Only the option :size is accepted, got ' + 
+          "#{options.keys.join(', ')}."
+      end
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated distinct is not ' + 
+          'implemented.'
+      end
+      
+      @model.add_constraint Distinct::DistinctConstraint.new(
+        @model, @params.update(options))
+    end
+    
+    # Adds a constraint on the sets that specifies that they must have at most
+    # one element in common. The "option" :size must be specified, the sets 
+    # will be constrained to that size.
+    def at_most_share_one_element(options = {})
+      unless options.has_key? :size
+        raise ArgumentError, 'Option :size has to be specified.'
+      end
+      unless options.size == 1
+        raise ArgumentError, 'Only the option :size is accepted, got ' + 
+          "#{options.keys.join(', ')}."
+      end
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated atmost one ' + 
+          'constrain is not implemented.'
+      end
+      
+      @model.add_constraint Distinct::AtMostOneConstraint.new(
+        @model, @params.update(options))
+    end
+  end
+  
+  # A module that gathers the classes and modules used in distinct constraints.
+  module Distinct
+    # Describes a set distinct constraint.
+    class DistinctConstraint < Gecode::Constraints::Constraint
+      def post
+        sets, size = @params.values_at(:lhs, :size)
+        Gecode::Raw::distinct(@model.active_space, sets.to_set_var_array, size)
+      end
+    end
+    
+    # Describes an at most one set constraint.
+    class AtMostOneConstraint < Gecode::Constraints::Constraint
+      def post
+        sets, size = @params.values_at(:lhs, :size)
+        Gecode::Raw::atmostOne(@model.active_space, sets.to_set_var_array, size)
+      end
+    end
+  end
+end