gecoder 0.2.0 → 0.3.0

data/lib/gecoder/interface/variables.rb

@@ -0,0 +1,62 @@
+module Gecode
+  # An variable that is bound to a model, but not to a particular space.  
+  class FreeVarBase
+    attr_accessor :model
+  
+    # Creates an int variable with the specified index.
+    def initialize(model, index)
+      @model = model
+      @index = index
+      @bound_space = @bound_var = nil
+    end
+    
+    private
+    
+    # Returns the space that the int variable should bind to when needed.
+    def active_space
+      @model.active_space
+    end
+  end
+  
+  # Creates a class for a free variable that can be bound into the specified
+  # class using the specified method in a space.
+  def Gecode::FreeVar(bound_class, space_bind_method)
+    clazz = Class.new(FreeVarBase)
+    clazz.class_eval <<-"end_method_definitions"
+      # Delegate methods we can't handle to the bound int variable if possible.
+      def method_missing(name, *args)
+        if #{bound_class}.instance_methods.include? name.to_s
+          bind.send(name, *args)
+        else
+          super
+        end
+      end
+      
+      # Binds the int variable to the currently active space of the model, 
+      # returning the bound int variable.
+      def bind
+        space = active_space
+        unless @bound_space == space
+          # We have not bound the variable to this space, so we do it now.
+          @bound = space.method(:#{space_bind_method}).call(@index)
+          @bound_space = space
+        end
+        return @bound
+      end
+      
+      def inspect
+        if assigned?
+          "#<#{bound_class} range: \#{val.to_s}>"
+        else
+          "#<#{bound_class} range: \#{min}..\#{max}>"
+        end
+      end
+    end_method_definitions
+    return clazz
+  end
+  
+  # Int variables.
+  FreeIntVar = FreeVar(Gecode::Raw::IntVar, :int_var)
+  # Bool variables.
+  FreeBoolVar = FreeVar(Gecode::Raw::BoolVar, :bool_var)
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: gecoder
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
-date: 2007-06-19 00:00:00 +02:00
+  version: 0.3.0
+date: 2007-06-26 00:00:00 +02:00
 summary: Ruby interface to Gecode, an environment for constraint programming.
 require_paths: 
 - lib
@@ -33,6 +33,7 @@ files:
 - README
 - COPYING
 - LGPL-LICENSE
+- CHANGES
 - lib/gecoder.rb
 - lib/gecoder/interface.rb
 - lib/gecoder/bindings.rb
@@ -42,9 +43,14 @@ files:
 - lib/gecoder/interface/binding_changes.rb
 - lib/gecoder/interface/branch.rb
 - lib/gecoder/interface/enum_wrapper.rb
-- lib/gecoder/interface/constraints/distinct.rb
-- lib/gecoder/interface/constraints/relation.rb
-- lib/gecoder/interface/constraints/linear.rb
+- lib/gecoder/interface/variables.rb
+- lib/gecoder/interface/constraints/reifiable_constraints.rb
+- lib/gecoder/interface/constraints/bool_var_constraints.rb
+- lib/gecoder/interface/constraints/int_var_constraints.rb
+- lib/gecoder/interface/constraints/int_enum_constraints.rb
+- lib/gecoder/interface/constraints/bool/boolean.rb
+- lib/gecoder/interface/constraints/int/linear.rb
+- lib/gecoder/interface/constraints/int_enum/distinct.rb
 - lib/gecoder/bindings/bindings.rb
 - vendor/rust
 - vendor/rust/test
@@ -130,9 +136,14 @@ extra_rdoc_files:
 - lib/gecoder/interface/binding_changes.rb
 - lib/gecoder/interface/branch.rb
 - lib/gecoder/interface/enum_wrapper.rb
-- lib/gecoder/interface/constraints/distinct.rb
-- lib/gecoder/interface/constraints/relation.rb
-- lib/gecoder/interface/constraints/linear.rb
+- lib/gecoder/interface/variables.rb
+- lib/gecoder/interface/constraints/reifiable_constraints.rb
+- lib/gecoder/interface/constraints/bool_var_constraints.rb
+- lib/gecoder/interface/constraints/int_var_constraints.rb
+- lib/gecoder/interface/constraints/int_enum_constraints.rb
+- lib/gecoder/interface/constraints/bool/boolean.rb
+- lib/gecoder/interface/constraints/int/linear.rb
+- lib/gecoder/interface/constraints/int_enum/distinct.rb
 - lib/gecoder/bindings/bindings.rb
 executables: []
 

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

@@ -1,15 +0,0 @@
-module Gecode
-  class IntVarEnumConstraintExpression
-    # Posts a distinct constraint on the variables in the enum.
-    def distinct
-      if @negate
-        # The best we could implement it as from here would be a bunch of 
-        # reified pairwise equality constraints. 
-        raise Gecode::MissingConstraintError, 'A negated distinct has not ' + 
-          'been implemented.'
-      end
-      
-      Gecode::Raw::distinct(@space, @var_array, Gecode::Raw::ICL_DEF)
-    end
-  end
-end

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

@@ -1,158 +0,0 @@
-module Gecode
-  class FreeIntVar
-    # Creates a linear expression where the int variables are summed.
-    def +(var)
-      Gecode::LinearConstraintExpressionNode.new(self, active_space) + var
-    end
-    
-    # Creates a linear expression where the int variable is multiplied with 
-    # a constant integer.
-    def *(int)
-      Gecode::LinearConstraintExpressionNode.new(self, active_space) * int
-    end
-    
-    # Creates a linear expression where the specified variable is subtracted 
-    # from this one.
-    def -(var)
-      Gecode::LinearConstraintExpressionNode.new(self, active_space) - var
-    end
-  end
-  
-  module LinearConstraintHelper
-    OPERATION_TYPES = [:+, :-, :*]
-  
-    # Define methods for the available operations.
-    OPERATION_TYPES.each do |name|
-      module_eval <<-"end_code"
-        def #{name}(expression)
-          unless expression.kind_of? Gecode::LinearConstraintExpressionTree
-            expression = Gecode::LinearConstraintExpressionNode.new(expression)
-          end
-          Gecode::LinearConstraintExpressionTree.new(self, expression, :#{name})
-        end
-      end_code
-    end
-    
-    # Specifies that a constraint must hold for the linear expression.
-    def must
-      Gecode::LinearConstraintExpression.new(self)
-    end
-    
-    # Specifies that the negation of a constraint must hold for the linear
-    # expression.
-    def must_not
-      Gecode::LinearConstraintExpression.new(self, true)
-    end
-  end
-  
-  # Describes a linear constraint that starts with a linear expression followed 
-  # by must or must_not.
-  class LinearConstraintExpressionTree
-    include Gecode::LinearConstraintHelper
-  
-    # Constructs a new expression with the specified variable
-    def initialize(left_node, right_node, operation)
-      @left = left_node
-      @right = right_node
-      @operation = operation
-    end
-    
-    # Converts the linear expression to an instance of 
-    # Gecode::Raw::MiniModel::LinExpr
-    def to_minimodel_lin_exp
-      @left.to_minimodel_lin_exp.send(@operation, @right.to_minimodel_lin_exp)
-    end
-    
-    # Fetches the space that the expression's variables is in.
-    def space
-      @left.space || @right.space
-    end
-  end
-  
-  # Describes a single node in a linear constrain expression.
-  class LinearConstraintExpressionNode
-    include Gecode::LinearConstraintHelper
-  
-    attr :space
-  
-    def initialize(value, space = nil)
-      @value = value
-      @space = space
-    end
-    
-    # Converts the linear expression to an instance of 
-    # Gecode::Raw::MiniModel::LinExpr
-    def to_minimodel_lin_exp
-      expression = @value
-      if expression.kind_of? FreeIntVar
-        # Minimodel requires that we do this first.
-        expression = expression.bind * 1
-      end
-      expression
-    end
-  end
-  
-  # Describes a linear constraint expression that starts with a linear 
-  # expression followed by must or must_not.
-  class LinearConstraintExpression
-    # TODO: this is awfully similar to IntVarConstrainExpression. There should
-    # be some way to combine them.
-  
-    # Maps the names of the methods to the corresponding integer relation 
-    # type in Gecode.
-    RELATION_TYPES = { 
-      :== => Gecode::Raw::IRT_EQ,
-      :<= => Gecode::Raw::IRT_LQ,
-      :<  => Gecode::Raw::IRT_LE,
-      :>= => Gecode::Raw::IRT_GQ,
-      :>  => Gecode::Raw::IRT_GR }
-    # The same as above, but negated.
-    NEGATED_RELATION_TYPES = {
-      :== => Gecode::Raw::IRT_NQ,
-      :<= => Gecode::Raw::IRT_GR,
-      :<  => Gecode::Raw::IRT_GQ,
-      :>= => Gecode::Raw::IRT_LE,
-      :>  => Gecode::Raw::IRT_LQ
-    }
-    
-    # Constructs the expression with the specified left hand side. The 
-    # expression can optionally be negated.
-    def initialize(left_hand_side, negate = false)
-      @lhs = left_hand_side
-      unless negate
-        @method_relations = RELATION_TYPES
-      else
-        @method_relations = NEGATED_RELATION_TYPES
-      end
-    end
-    
-    RELATION_TYPES.each_key do |name|
-      module_eval <<-"end_code"
-        def #{name}(expression)
-          post_relation_constraint(@method_relations[:#{name}], expression)
-        end
-      end_code
-    end
-    
-    private
-    
-    # Places the relation constraint corresponding to the specified (integer)
-    # relation type (as specified by Gecode) in relation to the specifed 
-    # element.
-    # 
-    # Raises TypeError if the element is of a type that doesn't allow a relation
-    # to be specified.
-    def post_relation_constraint(relation_type, right_hand_side)
-      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
-        raise TypeError, 'Invalid right hand side of linear equation.'
-      end
-      
-      (@lhs.to_minimodel_lin_exp - right_hand_side).post(@lhs.space, 
-        relation_type, Gecode::Raw::ICL_DEF)
-    end
-  end
-end

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

@@ -1,76 +0,0 @@
-module Gecode
-  class FreeIntVar
-    # Specifies that a constraint must hold for the integer variable.
-    def must
-      Gecode::IntVarConstraintExpression.new(active_space, self.bind)
-    end
-    
-    # Specifies that the negation of a constraint must hold for the integer 
-    # variable.
-    def must_not
-      Gecode::IntVarConstraintExpression.new(active_space, self.bind, true)
-    end
-  end
-  
-  # Describes a constraint expression that starts with a single integer variable
-  # followed by must or must_not.
-  class IntVarConstraintExpression
-    private
-    
-    # Maps the names of the methods to the corresponding integer relation 
-    # type in Gecode.
-    RELATION_TYPES = { 
-      :== => Gecode::Raw::IRT_EQ,
-      :<= => Gecode::Raw::IRT_LQ,
-      :<  => Gecode::Raw::IRT_LE,
-      :>= => Gecode::Raw::IRT_GQ,
-      :>  => Gecode::Raw::IRT_GR }
-    # The same as above, but negated.
-    NEGATED_RELATION_TYPES = {
-      :== => Gecode::Raw::IRT_NQ,
-      :<= => Gecode::Raw::IRT_GR,
-      :<  => Gecode::Raw::IRT_GQ,
-      :>= => Gecode::Raw::IRT_LE,
-      :>  => Gecode::Raw::IRT_LQ
-    }
-      
-    public
-    
-    # Constructs a new expression with the specified space and (bound) variable 
-    # as source. The expression can optionally be negated.
-    def initialize(space, var, negate = false)
-      @space = space
-      @var = var
-      unless negate
-        @method_relations = RELATION_TYPES
-      else
-        @method_relations = NEGATED_RELATION_TYPES
-      end
-    end
-    
-    RELATION_TYPES.each_key do |name|
-      module_eval <<-"end_code"
-        def #{name}(element)
-          post_relation_constraint(@method_relations[:#{name}], element)
-        end
-      end_code
-    end
-    
-    private
-    
-    # Places the relation constraint corresponding to the specified (integer)
-    # relation type (as specified by Gecode) in relation to the specifed 
-    # element.
-    # 
-    # Raises TypeError if the element is of a type that doesn't allow a relation
-    # to be specified.
-    def post_relation_constraint(relation_type, element)
-      if element.kind_of? Fixnum
-        Gecode::Raw::rel(@space, @var, relation_type, element, 
-          Gecode::Raw::ICL_DEF)
-      else
-        raise TypeError, 'Relations only allow Fixnum.'
-      end
-    end
-  end
-end