gecoder 0.4.0 → 0.5.0

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

@@ -8,30 +8,15 @@ module Gecode
           "#{element.class}."
       end
       params = {:lhs => self, :element => element}
-      return Gecode::Constraints::IntEnum::Count::ExpressionStub.new(
-        @model, params)
+      Gecode::Constraints::SimpleExpressionStub.new(@model, params) do |m, ps|
+        Gecode::Constraints::IntEnum::Count::Expression.new(m, ps)
+      end
     end
   end
 end
 
 # A module that gathers the classes and modules used in count constraints.
 module Gecode::Constraints::IntEnum::Count
-
-
-  # Describes an expression stub started with an int var enum followed by
-  # #count .
-  class ExpressionStub < Gecode::Constraints::ExpressionStub
-    include Gecode::Constraints::LeftHandSideMethods
-    
-    private
-    
-    # Produces an expression with the element for the lhs module.
-    def expression(params)
-      params.update(@params)
-      Gecode::Constraints::IntEnum::Count::Expression.new(@model, params)
-    end
-  end
-  
   # Describes an expression 
   class Expression < Gecode::Constraints::IntEnum::Expression
     def initialize(model, params)

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

@@ -7,8 +7,10 @@ module Gecode
         offsets = *offsets
       end
       params = {:lhs => self, :offsets => offsets}
-      return Gecode::Constraints::IntEnum::Distinct::OffsetExpressionStub.new(
-        @model, params)
+      
+      Gecode::Constraints::SimpleExpressionStub.new(@model, params) do |m, ps|
+        Gecode::Constraints::IntEnum::Expression.new(m, ps)
+      end
     end
   end
 end
@@ -31,20 +33,6 @@ module Gecode::Constraints::IntEnum
   
   # A module that gathers the classes and modules used in distinct constraints.
   module Distinct
-    # Describes an expression started with an int var enum following with
-    # #with_offsets .
-    class OffsetExpressionStub < Gecode::Constraints::ExpressionStub
-      include Gecode::Constraints::LeftHandSideMethods
-      
-      private
-      
-      # Produces an expression with offsets for the lhs module.
-      def expression(params)
-        params.update(@params)
-        Gecode::Constraints::IntEnum::Expression.new(@model, params)
-      end
-    end
-    
     # Describes a distinct constraint (optionally with offsets).
     class DistinctConstraint < Gecode::Constraints::Constraint
       def post

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

@@ -2,29 +2,18 @@
 module Gecode::Constraints::IntEnum::Element 
   # Describes an expression stub started with an int var enum following with an 
   # array access using an integer variables .
-  class ExpressionStub < Gecode::Constraints::ExpressionStub
-    include Gecode::Constraints::LeftHandSideMethods
-    
-    private
-    
-    # Produces an expression with position for the lhs module.
-    def expression(params)
-      # We extract the integer and continue as if it had been specified as
-      # left hand side. This might be elegant, but it could get away with 
-      # fewer constraints at times (when only equality is used) and 
-      # propagation strength can't be specified. 
-      # TODO: cut down on the number of constraints when possible. See if 
-      # there's some neat way of getting the above remarks. 
+  class ExpressionStub < Gecode::Constraints::Int::CompositeStub
+    def constrain_equal(variable, params)
+      enum, position, strength = @params.values_at(:lhs, :position, :strength)
+      if variable.nil?
+        variable = @model.int_var(enum.domain_range)
+      end
       
-      params.update(@params)
-      enum, position = params.values_at(:lhs, :position)
-      tmp = @model.int_var(enum.domain_range)
+      # 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, tmp.bind, Gecode::Raw::ICL_DEF)
-      Gecode::Constraints::Int::Expression.new(@model, 
-        params.update(:lhs => tmp))
+        position.bind, variable.bind, strength)
+      return variable
     end
   end
   

data/lib/gecoder/interface/constraints/int_var_constraints.rb

@@ -16,6 +16,34 @@ module Gecode
   module Constraints::Int
     class Expression < Gecode::Constraints::Expression
     end
+    
+    # A composite expression which is an int expression with a left hand side 
+    # resulting from a previous constraint.
+    class CompositeExpression < Gecode::Constraints::CompositeExpression
+      # The block given should take three parameters. The first is the variable 
+      # that should be the left hand side, if it's nil then a new one should be
+      # created. The second is the has of parameters. The block should return 
+      # the variable used as left hand side.
+      def initialize(model, params, &block)
+        super(Expression, Gecode::FreeIntVar, model, params, &block)
+      end
+    end
+    
+    # Describes a stub that produces an int variable, which can then be used with 
+    # the normal int variable constraints. An example would be the element
+    # constraint.
+    #
+    #   int_enum[int_var].must > rhs
+    #
+    # The int_enum[int_var] part produces an int variable which the constraint
+    # ".must > rhs" is then applied to. In the above case two constraints (and
+    # one temporary variable) are required, but in the case of equality only 
+    # one constraint is required.
+    class CompositeStub < Gecode::Constraints::CompositeStub
+      def initialize(model, params)
+        super(CompositeExpression, model, params)
+      end
+    end
   end
 end
 

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

@@ -0,0 +1,56 @@
+module Gecode
+  class FreeSetVar
+    # Starts a constraint on all the size of the set.
+    def size
+      params = {:lhs => self}
+      Gecode::Constraints::Set::Cardinality::SizeExpressionStub.new(@model, params)
+    end
+  end
+end
+
+module Gecode::Constraints::Set
+  # A module that gathers the classes and modules used in cardinality 
+  # constraints.
+  module Cardinality
+    # Describes a cardinality constraint.
+    class CardinalityConstraint < Gecode::Constraints::Constraint
+      def post
+        var, range = @params.values_at(:lhs, :range)
+        Gecode::Raw::cardinality(@model.active_space, var.bind, range.first, 
+          range.last)
+      end
+    end
+    
+    # A custom composite stub to change the composite expression used.
+    class CompositeStub < Gecode::Constraints::CompositeStub
+      def initialize(model, params)
+        super(Expression, model, params)
+      end
+    end
+    
+    # Describes a cardinality expression started with set.size.must .
+    class Expression < Gecode::Constraints::Int::CompositeExpression
+      def in(range)
+        if range.kind_of?(Range) and !@params[:negate]
+          @params.update(:range => range)
+          @model.add_constraint CardinalityConstraint.new(@model, @params)
+        else
+          super(range)
+        end
+      end
+    end
+    
+    # Describes an expression stub started with a set variable followed by 
+    # #size .
+    class SizeExpressionStub < CompositeStub
+      def constrain_equal(variable, params)
+        lhs = @params[:lhs]
+        if variable.nil?
+          variable = @model.int_var(lhs.glb_size, lhs.lub_size)
+        end
+        Gecode::Raw::cardinality(@model.active_space, lhs.bind, variable.bind)
+        return variable
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+module Gecode::Constraints::Set
+  class Expression
+    Gecode::Constraints::Util::SET_RELATION_TYPES.each_pair do |name, type|
+      module_eval <<-"end_code"
+        # Creates a domain constraint using the specified constant set.
+        def #{name}(constant_set, options = {})
+          add_domain_constraint(:#{name}, constant_set, options)
+        end
+      end_code
+    end
+    alias_set_methods
+    
+    private
+    
+    # Adds a domain constraint for the specified relation name, constant set
+    # and options.
+    def add_domain_constraint(relation_name, constant_set, options)
+      @params[:rhs] = constant_set
+      @params[:relation] = relation_name
+      @params.update Gecode::Constraints::Set::Util.decode_options(options)
+      if relation_name == :==
+        @model.add_constraint Domain::EqualityDomainConstraint.new(@model, 
+          @params)
+      else
+        @model.add_constraint Domain::DomainConstraint.new(@model, @params)
+      end
+    end
+  end
+  
+  # A module that gathers the classes and modules used in domain constraints.
+  module Domain
+    # Describes a domain constraint for equality.
+    class EqualityDomainConstraint < Gecode::Constraints::ReifiableConstraint
+      def post
+        var, domain, reif_var, negate = @params.values_at(:lhs, :rhs, :reif, 
+          :negate)
+        if negate
+          rel_type = Gecode::Constraints::Util::NEGATED_SET_RELATION_TYPES[:==]
+        else
+          rel_type = Gecode::Constraints::Util::SET_RELATION_TYPES[:==]
+        end
+        
+        (params = []) << var.bind
+        params << rel_type
+        params << Gecode::Constraints::Util.constant_set_to_params(domain)
+        params << reif_var.bind if reif_var.respond_to? :bind
+        Gecode::Raw::dom(@model.active_space, *params.flatten)
+      end
+    end
+  
+    # Describes a domain constraint for the relations other than equality.
+    class DomainConstraint < Gecode::Constraints::ReifiableConstraint
+      def post
+        var, domain, reif_var, relation = @params.values_at(:lhs, :rhs, :reif, 
+          :relation)
+        
+        (params = []) << var.bind
+        params << Gecode::Constraints::Util::SET_RELATION_TYPES[relation]
+        params << Gecode::Constraints::Util.constant_set_to_params(domain)
+        params << reif_var.bind if reif_var.respond_to? :bind
+        Gecode::Raw::dom(@model.active_space, *params.flatten)
+      end
+      negate_using_reification
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+module Gecode
+  class FreeSetVar
+    # Starts a constraint on all the elements of the set.
+    def elements
+      params = {:lhs => self}
+      Gecode::Constraints::SimpleExpressionStub.new(@model, params) do |m, ps|
+        Gecode::Constraints::Set::Relation::ElementExpression.new(m, ps)
+      end
+    end
+  end
+end
+
+module Gecode::Constraints::Set
+  class Expression
+    Gecode::Constraints::Util::SET_RELATION_TYPES.each_pair do |name, type|
+      module_eval <<-"end_code"
+        # Wrap previous relation methods providing support for relation 
+        # constraints.
+        alias_method 'pre_relation_#{type}_method'.to_sym, :#{name}
+        
+        # Creates a relation constraint using the specified expression.
+        def #{name}(expression, options = {})
+          if expression.kind_of? Gecode::FreeSetVar
+            add_relation_constraint(:#{name}, expression, options)
+          else
+            # Send it on.
+            pre_relation_#{type}_method(expression, options)
+          end
+        end
+      end_code
+    end
+    alias_set_methods
+    
+    private
+    
+    # Adds a relation constraint for the specified relation name, set variable
+    # and options.
+    def add_relation_constraint(relation_name, set, options)
+      @params[:rhs] = set
+      @params[:relation] = relation_name
+      @params.update Gecode::Constraints::Set::Util.decode_options(options)
+      if relation_name == :==
+        @model.add_constraint Relation::EqualityRelationConstraint.new(@model, 
+          @params)
+      else
+        @model.add_constraint Relation::RelationConstraint.new(@model, @params)
+      end
+    end
+  end
+  
+  # A module that gathers the classes and modules used in relation constraints.
+  module Relation
+    # Describes a relation constraint for equality.
+    class EqualityRelationConstraint < Gecode::Constraints::ReifiableConstraint
+      def post
+        var, rhs, reif_var, negate = @params.values_at(:lhs, :rhs, :reif, 
+          :negate)
+        if negate
+          rel_type = Gecode::Constraints::Util::NEGATED_SET_RELATION_TYPES[:==]
+        else
+          rel_type = Gecode::Constraints::Util::SET_RELATION_TYPES[:==]
+        end
+        
+        (params = []) << var.bind
+        params << rel_type
+        params << rhs.bind
+        params << reif_var.bind if reif_var.respond_to? :bind
+        Gecode::Raw::rel(@model.active_space, *params)
+      end
+    end
+  
+    # Describes a relation constraint for the relations other than equality.
+    class RelationConstraint < Gecode::Constraints::ReifiableConstraint
+      def post
+        var, rhs, reif_var, relation = @params.values_at(:lhs, :rhs, :reif, 
+          :relation)
+        
+        (params = []) << var.bind
+        params << Gecode::Constraints::Util::SET_RELATION_TYPES[relation]
+        params << rhs.bind
+        params << reif_var.bind if reif_var.respond_to? :bind
+        Gecode::Raw::rel(@model.active_space, *params)
+      end
+      negate_using_reification
+    end
+    
+    # Describes a relation constraint on the elements of a set.
+    class ElementRelationConstraint < Gecode::Constraints::Constraint
+      def post
+        var, rhs, relation = @params.values_at(:lhs, :rhs, :relation)
+        
+        if @params[:negate]
+          type = Gecode::Constraints::Util::NEGATED_RELATION_TYPES[relation]
+        else
+          type = Gecode::Constraints::Util::RELATION_TYPES[relation]
+        end
+
+        if rhs.kind_of? Fixnum
+          # Use a proxy int variable to cover.
+          rhs = @model.int_var(rhs)
+        end
+        Gecode::Raw::rel(@model.active_space, var.bind, type, rhs.bind)
+      end
+    end
+    
+    # Describes an expression which starts with set.element.must* .
+    class ElementExpression < Gecode::Constraints::Expression
+      Gecode::Constraints::Util::RELATION_TYPES.each_key do |name|
+        module_eval <<-"end_code"
+          # Creates an elements constraint using the specified expression, which
+          # may be either a constant integer of variable.
+          def #{name}(expression)
+            unless expression.kind_of?(Fixnum) or 
+                expression.kind_of?(Gecode::FreeIntVar)
+              raise TypeError, "Invalid expression type \#{expression.class}."
+            end
+            @params.update(:rhs => expression, :relation => :#{name})
+            @model.add_constraint ElementRelationConstraint.new(@model, @params)
+          end
+        end_code
+      end
+      alias_comparison_methods
+    end
+  end
+end

data/lib/gecoder/interface/constraints/set_var_constraints.rb

@@ -0,0 +1,37 @@
+module Gecode
+  class FreeSetVar
+    include Gecode::Constraints::LeftHandSideMethods
+    
+    private
+    
+    # Produces an expression for the lhs module.
+    def expression(params)
+      params.update(:lhs => self)
+      Constraints::Set::Expression.new(@model, params)
+    end
+  end
+  
+  # A module containing constraints that have set variables as left hand side
+  # (but not enumerations).
+  module Constraints::Set
+    # An expression with a set as left hand side.
+    class Expression < Gecode::Constraints::Expression
+    end
+    
+    # Utility methods for sets.
+    module Util
+      module_function
+      def decode_options(options)
+        if options.has_key? :strength
+          raise ArgumentError, 'Set constraints do not support the strength ' +
+            'option.'
+        end
+        Gecode::Constraints::Util.decode_options(options)
+      end
+    end
+  end
+end
+
+require 'gecoder/interface/constraints/set/domain'
+require 'gecoder/interface/constraints/set/relation'
+require 'gecoder/interface/constraints/set/cardinality'