gecoder 0.8.2 → 0.8.3

data/lib/gecoder/interface/binding_changes.rb

@@ -1,309 +1,9 @@
-# This file adds a small layer on top of the bindings. It alters the allocation 
-# of variables so that a single array is allocated in each space which is then 
-# used to store variable. The variables themselves are not directly returned, 
-# rather they are represented as the index in that store, which allows the 
-# variable to be retrieved back given a space.
-#
-# This layer should be moved to the C++ side instead when possible for better
-# performance.
+# This file adds a small layer on top of the bindings.
 module GecodeRaw #:nodoc: all
   class Space
-    # Creates the specified number of integer variables in the space with the
-    # specified domain. Returns the indices with which they can then be 
-    # accessed using int_var. The domain can be given as a Range (trated 
-    # specially) or as another enum.
-    def new_int_vars(domain, count = 1)
-      int_var_store.new_vars(domain, count)
-    end
-    
-    # Gets the int variable with the specified index, nil if none exists.
-    def int_var(index)
-      int_var_store[index]
-    end
-    
-    # Creates the specified number of boolean variables in the space. Returns
-    # 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 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
-    
     # Used by Gecode during BAB-search.
     def constrain(best_so_far_space)
       Gecode::Model.constrain(self, best_so_far_space)
     end
-    
-    # Refreshes the underlying stores used by the space.
-    def refresh
-      @int_var_store = nil
-      @bool_var_store = nil
-      @set_var_store = nil
-    end
-    
-    private
-    
-    # Retrieves the store used for integer variables. Creates one if none
-    # exists.
-    def int_var_store
-      # TODO: caching interferes with the variable creation during BAB-search,
-      # find out why.
-      #if @int_var_store.nil?
-        @int_var_store = Gecode::Util::IntVarStore.new(self) 
-      #end
-      return @int_var_store
-    end
-    
-    # Retrieves the store used for boolean variables. Creates one if none
-    # exists.
-    def bool_var_store
-      #if @bool_var_store.nil?
-        @bool_var_store = Gecode::Util::BoolVarStore.new(self) 
-      #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
-end
-
-module Gecode
-  # Various utility (mainly used to change the behavior of the raw bindings).
-  module Util #:nodoc: all
-    # Provides common methods to the variable stores. The stores must provide
-    # @next_index, @var_array, @size, ARRAY_IDENTIFIER and #new_storage_array .
-    module VarStoreMethods
-      # Returns the int var with the specified index, nil if none exists.
-      def [](index)
-        if index < 0 or index >= @next_index
-          return nil
-        end
-        return @var_array.at(index)
-      end
-      
-      private
-      
-      # Grows the store to the new size.
-      def grow(new_size)
-        @var_array.enlargeArray(@space, new_size - @size)
-        @size = new_size
-      end
-    end
-  
-    # A store in which int variables are created and stored.
-    class IntVarStore
-      # Design note: The store used to double its size when it needed to grow
-      # leaving unallocated slots (in rev 16). This was changed to only growing
-      # the amount of space needed because the additional information about which
-      # slot is the next unallocated one could not be encoded without changes to
-      # the bindings (and without that information we can not deduce the store
-      # from the new copy of space). So for additional performance the bindings 
-      # should grow the array more than needed (when this is moved to the bindings).
-      
-      include VarStoreMethods
-      
-      private
-    
-      # A string that identifies the array used by the store.
-      ARRAY_IDENTIFIER = 'int_array'
-    
-      public
-      
-      # Creates a store for the specified space with the specified capacit.
-      def initialize(space)
-        @space = space
-        
-        @var_array = space.int_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 integer variables in the space with the
-      # specified domain. Returns the indices with which they can then be 
-      # accessed using int_var. The domain can be given as a Range (trated 
-      # specially) or as another enum.
-      def new_vars(domain, count = 1)
-        grow(@next_index + count) # See the design note for more information.
-        count.times do |i|
-          if domain.kind_of? Range
-            domain_params = [domain.first, domain.last] 
-          elsif domain.kind_of? Enumerable
-            arr = domain.to_a
-            domain_params = [Gecode::Raw::IntSet.new(arr, arr.size)]
-          else
-            raise TypeError, "Expected Enumerable, got #{domain.class}."
-          end
-
-          @var_array[@next_index] = Gecode::Raw::IntVar.new(@space, 
-            *domain_params)
-          @next_index += 1
-        end
-        
-        ((@next_index - count)...@next_index).to_a
-      end
-  
-      # Returns the int var with the specified index, nil if none exists.
-      def [](index)
-        if index < 0 or index >= @next_index
-          return nil
-        end
-        return @var_array.at(index)
-      end
-  
-      private
-      
-      # Creates a new storage array for int variables.
-      def new_storage_array(new_size)
-        arr = Gecode::Raw::IntVarArray.new(@space, new_size)
-        @space.own(arr, ARRAY_IDENTIFIER)
-        return arr
-      end
-    end
-    
-    # A store in which int variables are created and stored.
-    class BoolVarStore
-      # TODO: can we refactor this better seeing as IntVarStore and BoolVarStore
-      # are similar?
-      
-      include VarStoreMethods
-      
-      private
-    
-      # A string that identifies the array used by the store.
-      ARRAY_IDENTIFIER = 'bool_array'
-    
-      public
-      
-      # Creates a store for the specified space with the specified capacit.
-      def initialize(space)
-        @space = space
-      
-        @var_array = space.bool_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 new bool variables. Returns the indices 
-      # of the created variables as an array.
-      def new_vars(count = 1)
-        grow(@next_index + count) # See the design note for more information.
-        count.times do |i|
-          @var_array[@next_index] = Gecode::Raw::BoolVar.new(@space, 0, 1)
-          @next_index += 1
-        end
-        
-        ((@next_index - count)...@next_index).to_a
-      end
-  
-      private
-      
-      # Creates a new storage array for bool variables.
-      def new_storage_array(new_size)
-        arr = Gecode::Raw::BoolVarArray.new(@space, new_size)
-        @space.own(arr, ARRAY_IDENTIFIER)
-        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::SetLimits::CARD
-        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 fixnum, range or enumeration 
-      # into one or more parameters that describe the domain to 
-      # Gecode::Raw::SetVar .
-      def domain_to_args(domain)
-        Gecode::Constraints::Util.constant_set_to_int_set(domain)
-      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/branch.rb

@@ -1,13 +1,14 @@
 module Gecode
   class Model
-    # Specifies which variables that should be branched on. One can optionally
-    # also select which of the variables that should be used first with the
-    # :variable option and which value in that variable's domain that should be 
-    # used with the :value option. If nothing is specified then :variable uses
-    # :none and value uses :min.
+    # Specifies which variables that should be branched on (given as an
+    # enum of variables or as a single variable). One can optionally
+    # also select which of the variables that should be used first with
+    # the :variable option and which value in that variable's domain
+    # that should be used with the :value option. If nothing is
+    # specified then :variable uses :none and value uses :min.
     #
-    # The following values can be used with :variable for integer and boolean 
-    # enums:
+    # The following values can be used with :variable for integer and
+    # boolean enums:
     # [:none]                 The first unassigned variable.
     # [:smallest_min]         The one with the smallest minimum.
     # [:largest_min]          The one with the largest minimum.
@@ -58,10 +59,13 @@ module Gecode
     #                         elements
     #
     # The following values can be used with :value set enums: 
-    # enums:
     # [:min]        Selects the smallest value in the unknown part of the set.
     # [:max]        Selects the largest value in the unknown part of the set.
     def branch_on(variables, options = {})
+      if variables.respond_to? :bind
+        variables = wrap_enum [variables]
+      end
+
       if variables.respond_to? :to_int_var_array or 
           variables.respond_to? :to_bool_var_array
         add_branch(variables, options, Constants::BRANCH_INT_VAR_CONSTANTS, 
@@ -78,8 +82,8 @@ module Gecode
     
     # This is a hack to get RDoc to ignore the constants.
     module Constants #:nodoc:
-      # Maps the names of the supported variable branch strategies for integer and
-      # booleans to the corresponding constant in Gecode. 
+      # Maps the names of the supported variable branch strategies for
+      # integer and booleans to the corresponding constant in Gecode. 
       BRANCH_INT_VAR_CONSTANTS = {
         :none                 => Gecode::Raw::INT_VAR_NONE,
         :smallest_min         => Gecode::Raw::INT_VAR_MIN_MIN,
@@ -149,4 +153,4 @@ module Gecode
       end
     end
   end
-end
+end

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

@@ -26,16 +26,15 @@ module Gecode
     # Describes a boolean expression (following after must*).
     class Expression #:nodoc:
       def ==(expression, options = {})
-        unless expression.kind_of?(ExpressionTree) or 
-            expression.kind_of?(Gecode::FreeBoolVar) or 
-            expression.kind_of?(TrueClass) or expression.kind_of?(FalseClass) or
-            expression.respond_to?(:to_minimodel_lin_exp)
-          raise TypeError, 'Invalid right hand side of boolean equation.'
+        if expression.kind_of? Gecode::Constraints::Int::Linear::ExpressionTree
+          return expression.must == @params[:lhs]
+        end
+        unless expression.respond_to? :to_minimodel_bool_expr
+          expression = Constraints::Bool::ExpressionNode.new(expression, @model)
         end
-        
         @params.update Gecode::Constraints::Util.decode_options(options)
-        @model.add_constraint BooleanConstraint.new(@model, 
-          @params.update(:rhs => expression))
+        @params.update(:lhs => @params[:lhs], :rhs => expression)
+        @model.add_constraint BooleanConstraint.new(@model, @params)
       end
       alias_comparison_methods
       
@@ -47,14 +46,14 @@ module Gecode
       end
       
       # Constrains the boolean expression to be true.
-      def true
-        @params.update Gecode::Constraints::Util.decode_options({})
+      def true(options = {})
+        @params.update Gecode::Constraints::Util.decode_options(options)
         @model.add_constraint BooleanConstraint.new(@model, 
           @params.update(:rhs => true))
       end
       
       # Constrains the boolean expression to be false.
-      def false
+      def false(options = {})
         @params[:negate] = !@params[:negate]
         self.true
       end
@@ -136,32 +135,37 @@ module Gecode
         lhs, rhs, negate, reif_var = 
           @params.values_at(:lhs, :rhs, :negate, :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 lhs.kind_of?(Gecode::FreeBoolVar)
+          lhs = Constraints::Bool::ExpressionNode.new(lhs, @model)
+        end
+
+        bot_eqv = Gecode::Raw::IRT_EQ
+        bot_xor = Gecode::Raw::IRT_NQ
+
+        if rhs.respond_to? :to_minimodel_bool_expr
           if reif_var.nil?
-            Gecode::Raw::rel(space, lhs.bind, Gecode::Raw::BOT_EQV, rhs.bind, 
-              (!negate ? 1 : 0), *propagation_options)
+            tree = ExpressionTree.new(lhs, 
+              Gecode::Raw::MiniModel::BoolExpr::NT_EQV, rhs)
+            tree.to_minimodel_bool_expr.post(space, !negate, 
+              *propagation_options)
           else
-            if negate
-              Gecode::Raw::rel(space, lhs.bind, Gecode::Raw::BOT_XOR, rhs.bind, 
-                reif_var.bind, *propagation_options)
-            else
-              Gecode::Raw::rel(space, lhs.bind, Gecode::Raw::BOT_EQV, rhs.bind, 
-                reif_var.bind, *propagation_options)
-            end
+            tree = ExpressionTree.new(lhs, 
+              Gecode::Raw::MiniModel::BoolExpr::NT_EQV, rhs)
+            var = tree.to_minimodel_bool_expr.post(space, *propagation_options)
+            Gecode::Raw::rel(space, var, (negate ? bot_xor : bot_eqv),
+              reif_var.bind, *propagation_options)
           end
         else
           should_hold = !negate & rhs
           if reif_var.nil?
-            Gecode::Raw::MiniModel::BoolExpr.new(lhs.bind).post(space, 
-              should_hold, *propagation_options)
+            lhs.to_minimodel_bool_expr.post(space, should_hold, 
+              *propagation_options)
           else
-            Gecode::Raw::rel(space, lhs.bind, Gecode::Raw::BOT_EQV, 
-              reif_var.bind, (should_hold ? 1 : 0), *propagation_options)
+            var = lhs.to_minimodel_bool_expr.post(space, *propagation_options)
+            Gecode::Raw::rel(space, var, 
+              (should_hold ? bot_eqv : bot_xor),
+              reif_var.bind, *propagation_options)
           end
         end
       end
@@ -177,10 +181,10 @@ module Gecode
       # Maps the names of the methods to the corresponding bool constraint in 
       # Gecode.
       OPERATION_TYPES = {
-        :|        => Gecode::Raw::BOT_OR,
-        :&        => Gecode::Raw::BOT_AND,
-        :^        => Gecode::Raw::BOT_XOR,
-        :implies  => Gecode::Raw::BOT_IMP
+        :|        => Gecode::Raw::MiniModel::BoolExpr::NT_OR,
+        :&        => Gecode::Raw::MiniModel::BoolExpr::NT_AND,
+        :^        => Gecode::Raw::MiniModel::BoolExpr::NT_XOR,
+        :implies  => Gecode::Raw::MiniModel::BoolExpr::NT_IMP
       }
       
       public
@@ -191,13 +195,7 @@ module Gecode
             unless expression.kind_of? ExpressionTree
               expression = ExpressionNode.new(expression)
             end
-            ExpressionTree.new(self, expression) do |model, var1, var2|
-              new_var = model.bool_var
-              Gecode::Raw::rel(model.active_space, var1.bind, #{operation}, 
-                var2.bind, new_var.bind, Gecode::Raw::ICL_DEF, 
-                Gecode::Raw::PK_DEF)
-              new_var
-            end
+            ExpressionTree.new(self, #{operation}, expression)
           end
         end_code
       end
@@ -216,17 +214,19 @@ module Gecode
     class ExpressionTree #:nodoc:
       include OperationMethods
     
-      # 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)
+      # Constructs a new expression with the specified binary operation 
+      # applied to the specified trees.
+      def initialize(left_tree, operation, right_tree)
         @left = left_tree
+        @operation = operation
         @right = right_tree
-        @bind_proc = block
       end
       
-      # Returns a bound boolean variable representing the expression. 
-      def bind
-        @bind_proc.call(model, @left, @right).bind
+      # Returns a MiniModel boolean expression representing the tree.
+      def to_minimodel_bool_expr
+        Gecode::Raw::MiniModel::BoolExpr.new(
+          @left.to_minimodel_bool_expr, @operation, 
+          @right.to_minimodel_bool_expr)
       end
       
       # Fetches the space that the expression's variables is in.
@@ -242,14 +242,18 @@ module Gecode
       attr :model
     
       def initialize(value, model = nil)
+        unless value.kind_of?(Gecode::FreeBoolVar)
+          raise TypeError, 'Invalid type used in boolean equation: ' +
+            "#{value.class}."
+        end
         @value = value
         @model = model
       end
       
-      # Returns a bound boolean variable representing the expression. 
-      def bind
-        @value.bind
+      # Returns a MiniModel boolean expression representing the tree.
+      def to_minimodel_bool_expr
+        Gecode::Raw::MiniModel::BoolExpr.new(@value.bind)
       end
     end
   end
-end
+end

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

@@ -1,23 +1,8 @@
 module Gecode::Constraints::Bool
   class Expression
-    alias_method :pre_channel_equals, :==
-    
     # Constrains the boolean variable to be equal to the specified integer 
     # variable.
-    def ==(int, options = {})
-      unless @params[:lhs].kind_of?(Gecode::FreeBoolVar) and 
-          int.kind_of?(Gecode::FreeIntVar)
-        return pre_channel_equals(int, options)
-      end
-      
-      # Provide commutivity to the corresponding int variable constraint.
-      if @params[:negate]
-        int.must_not.equal(@params[:lhs], options)
-      else
-        int.must.equal(@params[:lhs], options)
-      end
-    end
-    
+    provide_commutivity(:==){ |rhs, _| rhs.kind_of?(Gecode::FreeIntVar) }
     alias_comparison_methods
   end
 end

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

@@ -6,7 +6,7 @@ module Gecode::Constraints::BoolEnum
     #
     # [:offset]  Specifies an offset for the integer variable. If the offset is
     #            set to k then the integer variable takes value i+k exactly 
-    #            when the variable at index i in the boolean enumration is true 
+    #            when the variable at index i in the boolean enumeration is true 
     #            and the rest are false.
     def channel(int_var, options = {})
       if @params[:negate]
@@ -25,28 +25,33 @@ module Gecode::Constraints::BoolEnum
       @params.update(Gecode::Constraints::Util.decode_options(options))
       @model.add_constraint Channel::ChannelConstraint.new(@model, @params)
     end
+
+    # Adds a channel constraint on the variables in the enum with the specified 
+    # set variable.
+    provide_commutivity(:channel){ |rhs, _| rhs.kind_of? Gecode::FreeSetVar }
   end
   
   # A module that gathers the classes and modules used in channel constraints
   # involving one boolean enum and one integer variable.
   module Channel #:nodoc:
-    # Describes a channel constraint that "channels" an enumerations of 
+    # Describes a channel constraint that "channels" an enumeration of 
     # boolean variables with an integer variable. This constrains the integer
     # variable to take value i exactly when the variable at index i in the 
     # boolean enumeration is true and the others are false.
     # 
-    # Neither reification nor negation is supported.
+    # Neither reification nor negation is supported. The int variable
+    # and the enumeration can be interchanged.
     #
     # == Examples
     #
-    # # Constrains the enumeration called +selected_option+ to be false in the
+    # # Constrains the enumeration called +option_is_selected+ to be false in the
     # # first four positions and have exactly one true variable in the other. 
-    # selected_option.must.channel selected_option_index 
+    # option_is_selected.must.channel selected_option_index 
     # selected_option_index.must_be > 3
     #
-    # # Constrains the enumeration called +selected_option+ to be false in the
+    # # Constrains the enumeration called +option_is_selected+ to be false in the
     # # first five positions and have exactly one true variable in the other. 
-    # selected_option.must.channel(selected_option_index, :offset => 1) 
+    # selected_option_index.must.channel(option_is_selected, :offset => 1) 
     # selected_option_index.must_be > 3
     class ChannelConstraint < Gecode::Constraints::Constraint
       def post
@@ -56,4 +61,4 @@ module Gecode::Constraints::BoolEnum
       end
     end
   end
-end
+end

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

@@ -25,6 +25,27 @@ module Gecode::Constraints::BoolEnum
       @model.add_constraint Extensional::TupleConstraint.new(@model, 
         @params.update(Gecode::Constraints::Util.decode_options(options)))
     end
+
+    # Adds a constraint that forces the enumeration to match the
+    # specified regular expression over the boolean domain. The regular
+    # expression is expressed using arrays and boolean values (or
+    # integers). See BoolEnum::Extensional::RegexpConstraint for more information 
+    # and examples of such regexps.
+    def match(regexp, options = {})
+      if @params[:negate]
+        raise Gecode::MissingConstraintError, 'A negated regexp constraint ' +
+          'is not implemented.'
+      end
+      unless options[:reify].nil?
+        raise ArgumentError, 'Reification is not supported by the regexp ' + 
+          'constraint.'
+      end
+
+      @params[:regexp] = 
+        Gecode::Constraints::Util::Extensional.parse_regexp regexp
+      @params.update Gecode::Constraints::Util.decode_options(options)
+      @model.add_constraint Extensional::RegexpConstraint.new(@model, @params)
+    end
   end
   
   # A module that gathers the classes and modules used in extensional 
@@ -60,5 +81,32 @@ module Gecode::Constraints::BoolEnum
           *propagation_options)
       end
     end
+
+    # Describes a regexp constraint, which constrains the enumeration of
+    # boolean variables to match a specified regexp in the boolean
+    # domain. Neither negation nor reification is supported.
+    #
+    # The regular expressions are specified as described in
+    # IntEnum::Extensional::RegexpConstraint but true and false can be
+    # used instead of integers.
+    #
+    # == Example
+    #
+    #   # Constrains the two boolean variables in +bools+ to be false
+    #   # and true respectively.
+    #   bools.must.match [false, true]
+    #
+    #   # Constrains the boolean variables in +bools+ to be false,
+    #   # except for three consecutive variables which should be true
+    #   # followed by false followed by true.
+    #   bools.must.match [repeat(false), true, false, true, repeat(false)]]
+    #
+    class RegexpConstraint < Gecode::Constraints::Constraint
+      def post
+        lhs, regexp = @params.values_at(:lhs, :regexp)
+        Gecode::Raw::extensional(@model.active_space, lhs.to_bool_var_array, 
+          regexp, *propagation_options)
+      end
+    end
   end
 end