gecoder 0.4.0 → 0.5.0

data/lib/gecoder/interface/binding_changes.rb

@@ -21,16 +21,31 @@ module Gecode
       end
       
       # Creates the specified number of boolean variables in the space. Returns
-      # the indices with which they can then be accessed using int_var.
+      # the indices with which they can then be accessed using bool_var.
       def new_bool_vars(count = 1)
         bool_var_store.new_vars(count)
       end
       
-      # Gets the int variable with the specified index, nil if none exists.
+      # Gets the bool variable with the specified index, nil if none exists.
       def bool_var(index)
         bool_var_store[index]
       end
       
+      # Creates the specified number of set variables in the space with the 
+      # specified domain for greatest lower bound and least upper bound 
+      # (specified as either a range or enum). A range for the allowed 
+      # cardinality of the set can also be specified, if none is specified, or 
+      # nil is given, then the default range (anything) will be used. Returns 
+      # the indices with which they can then be accessed using set_var.
+      def new_set_vars(*vars)
+        set_var_store.new_vars(*vars)
+      end
+      
+      # Gets the set variable with the specified index, nil if none exists.
+      def set_var(index)
+        set_var_store[index]
+      end
+      
       private
       
       # Retrieves the store used for integer variables. Creates one if none
@@ -50,6 +65,14 @@ module Gecode
         end
         return @bool_var_store
       end
+      
+      # Retrieves the store used for set variables. Creates one if none exists.
+      def set_var_store
+        if @set_var_store.nil?
+          @set_var_store = Gecode::Util::SetVarStore.new(self) 
+        end
+        return @set_var_store
+      end
     end
     
     class IntVar
@@ -67,6 +90,33 @@ module Gecode
       def true?
         val == 1
       end
+      
+      def false?
+        val == 0
+      end
+    end
+    
+    class SetVar
+      # Aliases to make method-names more ruby-like.
+      alias_method :assigned?, :assigned
+      
+      alias_method :include_glb?, :contains
+      alias_method :include?, :contains
+      def include_lub?(element)
+        !notContains(element)
+      end
+      
+      alias_method :glb_min, :glbMin
+      alias_method :glb_max, :glbMax
+      alias_method :lub_min, :lubMin
+      alias_method :lub_max, :lubMax
+      
+      alias_method :glb_size, :glbSize
+      alias_method :val_size, :glbSize
+      alias_method :lub_size, :lubSize
+      
+      alias_method :card_min, :cardMin
+      alias_method :card_max, :cardMax
     end
   end
   
@@ -209,5 +259,76 @@ module Gecode
         return arr
       end
     end
+    
+    # A store in which int variables are created and stored.
+    class SetVarStore
+      include VarStoreMethods
+      
+      private
+    
+      # A string that identifies the array used by the store.
+      ARRAY_IDENTIFIER = 'set_array'
+    
+      public
+      
+      # Creates a store for the specified space with the specified capacit.
+      def initialize(space)
+        @space = space
+      
+        @var_array = space.set_var_array(ARRAY_IDENTIFIER)
+        if @var_array.nil?
+          # Create a new one.
+          @var_array = new_storage_array(0)
+        end
+  
+        @size = @var_array.size
+        @next_index = @size
+      end
+      
+      # Creates the specified number of set variables in the space with the 
+      # specified domain for greatest lower bound and least upper bound 
+      # (specified as either a range or enum). A range for the allowed 
+      # cardinality of the set can also be specified, if none is specified, or 
+      # nil is given, then the default range (anything) will be used. Returns 
+      # the indices with which they can then be accessed using set_var.
+      def new_vars(glb_domain, lub_domain, cardinality_range = nil, count = 1)
+        grow(@next_index + count) # See the design note for more information.
+
+        if cardinality_range.nil?
+          cardinality_range = 0..Gecode::Raw::Limits::Set::CARD_MAX
+        end
+        
+        params = [@space]
+        params << domain_to_args(glb_domain)
+        params << domain_to_args(lub_domain)
+        params << cardinality_range.first << cardinality_range.last
+        count.times do |i|
+          @var_array[@next_index] = Gecode::Raw::SetVar.new(*params.flatten)
+          @next_index += 1
+        end
+        
+        ((@next_index - count)...@next_index).to_a
+      end
+  
+      private
+      
+      # Transforms a lub or glb domain given as a range or enumeration into one
+      # or more parameters that describe the domain to Gecode::Raw::SetVar .
+      def domain_to_args(domain)
+        if domain.kind_of? Range
+          return domain.first, domain.last
+        else
+          elements = domain.to_a
+          return Gecode::Raw::IntSet.new(domain, domain.size)
+        end
+      end
+      
+      # Creates a new storage array for bool variables.
+      def new_storage_array(new_size)
+        arr = Gecode::Raw::SetVarArray.new(@space, new_size)
+        @space.own(arr, ARRAY_IDENTIFIER)
+        return arr
+      end
+    end
   end
 end

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

@@ -7,71 +7,81 @@ module Gecode
     def &(var)
       Constraints::Bool::ExpressionNode.new(self, @model) & var
     end
+    
+    def ^(var)
+      Constraints::Bool::ExpressionNode.new(self, @model) ^ var
+    end
+    
+    def implies(var)
+      Constraints::Bool::ExpressionNode.new(self, @model).implies var
+    end
   end
   
+  # A module that gathers the classes and modules used in boolean constraints.
   module Constraints::Bool
+    # Describes a boolean expression (following after must*).
     class Expression
-      def ==(expression)
-        add_boolean_constraint(expression)
+      def ==(expression, options = {})
+        @params.update Gecode::Constraints::Util.decode_options(options)
+        @model.add_constraint BooleanConstraint.new(@model, 
+          @params.update(:rhs => expression))
       end
       alias_comparison_methods
       
+      # Constrains the boolean expression to imply the specified expression.
+      def imply(expression, options = {})
+        @params.update Gecode::Constraints::Util.decode_options(options)
+        @params.update(:lhs => @params[:lhs].implies(expression), :rhs => true)
+        @model.add_constraint BooleanConstraint.new(@model, @params)
+      end
+      
+      # Constrains the boolean expression to be true.
       def true
-        # Bind parameters.
-        lhs = @params[:lhs]
-        unless lhs.respond_to? :to_minimodel_lin_exp
-          lhs = ExpressionNode.new(lhs, @model)
-        end
-
+        @params.update Gecode::Constraints::Util.decode_options({})
         @model.add_constraint BooleanConstraint.new(@model, 
-          @params.update(:expression => lhs.to_minimodel_lin_exp))
+          @params.update(:rhs => true))
       end
       
+      # Constrains the boolean expression to be false.
       def false
-        # Bind parameters.
-        lhs = @params[:lhs]
-        unless lhs.respond_to? :to_minimodel_lin_exp
-          lhs = ExpressionNode.new(lhs, @model)
-        end
-        
-        @params.update(:expression => Gecode::Raw::MiniModel::BoolExpr.new(
-            lhs.to_minimodel_lin_exp, Gecode::Raw::MiniModel::BoolExpr::BT_NOT))
-        @model.add_constraint BooleanConstraint.new(@model, @params)
-      end
-      
-      private
-      
-      # Adds the boolean constraint corresponding to equivalence between the 
-      # left and right hand sides.
-      #
-      # Raises TypeError if the element is of a type that doesn't allow a 
-      # relation to be specified.
-      def add_boolean_constraint(right_hand_side = nil)
-        # Bind parameters.
-        lhs = @params[:lhs]
-        unless lhs.respond_to? :to_minimodel_lin_exp
-          lhs = ExpressionNode.new(lhs, @model)
-        end
-        unless right_hand_side.respond_to? :to_minimodel_lin_exp
-          right_hand_side = ExpressionNode.new(right_hand_side, @model)
-        end
-        
-        expression = ExpressionTree.new(lhs, right_hand_side, 
-          Gecode::Raw::MiniModel::BoolExpr::BT_EQV)
-        @model.add_constraint BooleanConstraint.new(@model, 
-          @params.update(:expression => expression.to_minimodel_lin_exp))
+        @params[:negate] = !@params[:negate]
+        self.true
       end
     end
     
     # Describes a boolean constraint.
     class BooleanConstraint < Gecode::Constraints::ReifiableConstraint
       def post
-        unless @params[:reif].nil?
-          @params[:expression] = Gecode::Raw::MiniModel::BoolExpr.new(
-            @params[:expression], Gecode::Raw::MiniModel::BoolExpr::BT_EQV, 
-            Gecode::Raw::MiniModel::BoolExpr.new(@params[:reif].bind))
+        lhs, rhs, negate, strength, reif_var = @params.values_at(:lhs, :rhs, 
+          :negate, :strength, :reif)
+        space = (lhs.model || rhs.model).active_space
+        
+        # TODO: It should be possible to reduce the number of necessary 
+        # variables and constraints a bit by altering the way that the top node
+        # is posted, using its constraint for reification etc when possible. 
+        
+        if rhs.respond_to? :bind
+          if reif_var.nil?
+            Gecode::Raw::bool_eqv(space, lhs.bind, rhs.bind, !negate, strength)
+          else
+            if negate
+              Gecode::Raw::bool_xor(space, lhs.bind, rhs.bind, reif_var.bind, 
+                strength)
+            else
+              Gecode::Raw::bool_eqv(space, lhs.bind, rhs.bind, reif_var.bind, 
+                strength)
+            end
+          end
+        else
+          should_hold = !negate & rhs
+          if reif_var.nil?
+            Gecode::Raw::MiniModel::BoolExpr.new(lhs.bind).post(space, 
+              should_hold)
+          else
+            Gecode::Raw::bool_eqv(space, lhs.bind, reif_var.bind, should_hold, 
+              strength)
+          end
         end
-        @params[:expression].post(@model.active_space, !@params[:negate])
       end
     end
   
@@ -82,11 +92,13 @@ module Gecode
       
       private
     
-      # Maps the names of the methods to the corresponding bool operation type
-      # in Gecode.
+      # Maps the names of the methods to the corresponding bool constraint in 
+      # Gecode.
       OPERATION_TYPES = {
-        :|  => Gecode::Raw::MiniModel::BoolExpr::BT_OR,
-        :&  => Gecode::Raw::MiniModel::BoolExpr::BT_AND
+        :|        => :bool_or,
+        :&        => :bool_and,
+        :^        => :bool_xor,
+        :implies  => :bool_imp
       }
       
       public
@@ -97,7 +109,12 @@ module Gecode
             unless expression.kind_of? ExpressionTree
               expression = ExpressionNode.new(expression)
             end
-            ExpressionTree.new(self, expression, #{operation})
+            ExpressionTree.new(self, expression) do |model, var1, var2|
+              new_var = model.bool_var
+              Gecode::Raw::#{operation}(model.active_space, var1.bind, var2.bind,
+                new_var.bind, Gecode::Raw::ICL_DEF)
+              new_var
+            end
           end
         end_code
       end
@@ -116,18 +133,17 @@ module Gecode
     class ExpressionTree
       include OperationMethods
     
-      # Constructs a new expression with the specified variable
-      def initialize(left_node, right_node, operation)
-        @left = left_node
-        @right = right_node
-        @operation = operation
+      # Constructs a new expression with the specified nodes. The proc should 
+      # take a model followed by two variables and return a new variable.
+      def initialize(left_tree, right_tree, &block)
+        @left = left_tree
+        @right = right_tree
+        @bind_proc = block
       end
       
-      # Converts the boolean expression to an instance of 
-      # Gecode::Raw::MiniModel::BoolExpr
-      def to_minimodel_lin_exp
-        Gecode::Raw::MiniModel::BoolExpr.new(@left.to_minimodel_lin_exp,
-          @operation, @right.to_minimodel_lin_exp)
+      # Returns a bound boolean variable representing the expression. 
+      def bind
+        @bind_proc.call(model, @left, @right).bind
       end
       
       # Fetches the space that the expression's variables is in.
@@ -147,10 +163,9 @@ module Gecode
         @model = model
       end
       
-      # Converts the linear expression to an instance of 
-      # Gecode::Raw::MiniModel::BoolExpr
-      def to_minimodel_lin_exp
-        Gecode::Raw::MiniModel::BoolExpr.new(@value.bind)
+      # Returns a bound boolean variable representing the expression. 
+      def bind
+        @value.bind
       end
     end
   end

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

@@ -0,0 +1,59 @@
+module Gecode
+  module BoolEnumMethods
+    # Produces an expression that can be handled as if it was a variable 
+    # representing the conjunction of all boolean variables in the enumeration.
+    def conjunction
+      return Gecode::Constraints::BoolEnum::ConjunctionStub.new(
+        @model, :lhs => self)
+    end
+    
+    # Produces an expression that can be handled as if it was a variable 
+    # representing the disjunction of all boolean variables in the enumeration.
+    def disjunction
+      return Gecode::Constraints::BoolEnum::DisjunctionStub.new(
+        @model, :lhs => self)
+    end
+  end
+  
+  module Constraints::BoolEnum
+    # Describes an expression stub started with a bool var enum following by 
+    # #conjunction.
+    class ConjunctionStub < Gecode::Constraints::Bool::CompositeStub
+      def constrain_equal(variable, params)
+        enum, strength = @params.values_at(:lhs, :strength)
+        if variable.nil?
+          variable = @model.bool_var
+        end
+        
+        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)
+        return variable
+      end
+    end
+    
+    # Describes an expression stub started with a bool var enum following by 
+    # #disjunction.
+    class DisjunctionStub < Gecode::Constraints::Bool::CompositeStub
+      def constrain_equal(variable, params)
+        enum, strength = @params.values_at(:lhs, :strength)
+        if variable.nil?
+          variable = @model.bool_var
+        end
+        
+        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)
+        return variable
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module Gecode  
+  # A module containing constraints that have enumerations of boolean variables 
+  # as left hand side.
+  module Constraints::BoolEnum
+  end
+end
+
+require 'gecoder/interface/constraints/bool_enum/boolean'

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

@@ -17,6 +17,48 @@ module Gecode
     # Describes a boolean expression.
     class Expression < Gecode::Constraints::Expression
     end
+    
+    # A composite expression which is an bool 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
+      
+      # Override to also deal with constant booleans.
+      def true(options = {})
+        # We don't need any additional constraints.
+        @params.update Gecode::Constraints::Util.decode_options(options)
+        @proc.call(!@params[:negate], @params)
+      end
+      
+      # Override to also deal with constant booleans.
+      def false(options = {})
+        # We don't need any additional constraints.
+        @params.update Gecode::Constraints::Util.decode_options(options)
+        @proc.call(@params[:negate], @params)
+      end
+    end
+    
+    # Describes a stub that produces an int variable, which can then be used with 
+    # the normal bool variable constraints. An example for boolean composite 
+    # constraints would be conjunction.
+    #
+    #   bools.conjunction.must == b1 | b2
+    # 
+    # "bools.conjunction" produces a bool variable which the constraint 
+    # ".must == b1 | b2" 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/int/arithmetic.rb

@@ -22,56 +22,33 @@ end
 module Gecode::Constraints::Int::Arithmetic 
   # Describes an expression stub started with an integer variable followed by 
   # #abs .
-  class AbsExpressionStub < Gecode::Constraints::ExpressionStub
-    include Gecode::Constraints::LeftHandSideMethods
-    
-    private
-    
-    # Produces a proxy expression 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 AbsExpressionStub < Gecode::Constraints::Int::CompositeStub
+    def constrain_equal(variable, params)
+      lhs, strength = @params.values_at(:lhs, :strength)
+      if variable.nil?
+        variable = @model.int_var(lhs.min..lhs.max)
+      end
       
-      params.update(@params)
-      lhs = params[:lhs]
-      proxy = @model.int_var(lhs.min..lhs.max)
-      lhs = lhs.bind
-      
-      Gecode::Raw::abs(@model.active_space, lhs, proxy.bind, 
-        Gecode::Raw::ICL_DEF)
-      Gecode::Constraints::Int::Expression.new(@model, 
-        params.update(:lhs => proxy))
+      Gecode::Raw::abs(@model.active_space, lhs.bind, variable.bind, strength)
+      return variable
     end
   end
   
   # Describes an expression stub started with an integer variable followed by 
   # #* .
-  class MultExpressionStub < Gecode::Constraints::ExpressionStub
-    include Gecode::Constraints::LeftHandSideMethods
-    
-    private
-    
-    # Produces a proxy expression 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. 
-      
-      params.update(@params)
-      lhs, var = params.values_at(:lhs, :var)
-      proxy = @model.int_var(-(lhs.min*var.min).abs..(lhs.max*var.max).abs) # Sloppy
-      
-      Gecode::Raw::mult(@model.active_space, lhs.bind, var.bind, proxy.bind, 
-        Gecode::Raw::ICL_DEF)
-      Gecode::Constraints::Int::Expression.new(@model, 
-        params.update(:lhs => proxy))
+  class MultExpressionStub < Gecode::Constraints::Int::CompositeStub
+    def constrain_equal(variable, params)
+      lhs, lhs2, strength = @params.values_at(:lhs, :var, :strength)
+      if variable.nil?
+        a_min = lhs.min; a_max = lhs.max
+        b_min = lhs2.min; b_max = lhs2.max
+        products = [a_min*b_min, a_min*b_max, a_max*b_min, a_max*b_max]
+        variable = @model.int_var(products.min..products.max)
+      end
+
+      Gecode::Raw::mult(@model.active_space, lhs.bind, lhs2.bind, 
+        variable.bind, strength)
+      return variable
     end
   end
 end

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

@@ -6,9 +6,11 @@ module Gecode::Constraints::Int
       @params[:domain] = domain
       if domain.kind_of? Range
         @model.add_constraint Domain::RangeDomainConstraint.new(@model, @params)
-      else
-        @model.add_constraint Domain::NonRangeDomainConstraint.new(@model, 
+      elsif domain.kind_of?(Enumerable) and domain.all?{ |e| e.kind_of? Fixnum }
+        @model.add_constraint Domain::EnumDomainConstraint.new(@model, 
           @params)
+      else
+        raise TypeError, "Expected integer enumerable, got #{domain.class}."
       end
     end
   end
@@ -29,8 +31,8 @@ module Gecode::Constraints::Int
       negate_using_reification
     end
     
-    # Describes a non-range domain constraint.
-    class NonRangeDomainConstraint < Gecode::Constraints::ReifiableConstraint
+    # Describes a enum domain constraint.
+    class EnumDomainConstraint < Gecode::Constraints::ReifiableConstraint
       def post
         space = @model.active_space
       

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

@@ -17,56 +17,30 @@ end
 # A module that gathers the classes and modules used by arithmetic constraints.
 module Gecode::Constraints::IntEnum::Arithmetic 
   # Describes an expression stub started with an int var enum following by #max.
-  class MaxExpressionStub < Gecode::Constraints::ExpressionStub
-    include Gecode::Constraints::LeftHandSideMethods
-    
-    private
-    
-    # Produces an expression 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 MaxExpressionStub < Gecode::Constraints::Int::CompositeStub
+    def constrain_equal(variable, params)
+      enum, strength = @params.values_at(:lhs, :strength)
+      if variable.nil?
+        variable = @model.int_var(enum.domain_range)
+      end
       
-      params.update(@params)
-      lhs = params[:lhs]
-      proxy = @model.int_var(lhs.domain_range)
-      lhs = lhs.to_int_var_array
-      
-      Gecode::Raw::max(@model.active_space, lhs, proxy.bind, 
-        Gecode::Raw::ICL_DEF)
-      Gecode::Constraints::Int::Expression.new(@model, 
-        params.update(:lhs => proxy))
+      Gecode::Raw::max(@model.active_space, enum.to_int_var_array, 
+        variable.bind, strength)
+      return variable
     end
   end
   
   # Describes an expression stub started with an int var enum following by #min.
-  class MinExpressionStub < Gecode::Constraints::ExpressionStub
-    include Gecode::Constraints::LeftHandSideMethods
-    
-    private
-    
-    # Produces an expression 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. 
-      
-      params.update(@params)
-      lhs = params[:lhs]
-      proxy = @model.int_var(lhs.domain_range)
-      lhs = lhs.to_int_var_array
+  class MinExpressionStub < Gecode::Constraints::Int::CompositeStub
+    def constrain_equal(variable, params)
+      enum, strength = @params.values_at(:lhs, :strength)
+      if variable.nil?
+        variable = @model.int_var(enum.domain_range)
+      end
       
-      Gecode::Raw::min(@model.active_space, lhs, proxy.bind, 
-        Gecode::Raw::ICL_DEF)
-      Gecode::Constraints::Int::Expression.new(@model, 
-        params.update(:lhs => proxy))
+      Gecode::Raw::min(@model.active_space, enum.to_int_var_array, 
+        variable.bind, strength)
+      return variable
     end
   end
 end