gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.2.0/test/test.icc

@@ -0,0 +1,93 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Christian Schulte <schulte@gecode.org>
+ *
+ *  Copyright:
+ *     Christian Schulte, 2007
+ *
+ *  Last modified:
+ *     $Date: 2007-11-13 16:40:29 +0100 (Tue, 13 Nov 2007) $ by $Author: zayenz $
+ *     $Revision: 5284 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ *  Permission is hereby granted, free of charge, to any person obtaining
+ *  a copy of this software and associated documentation files (the
+ *  "Software"), to deal in the Software without restriction, including
+ *  without limitation the rights to use, copy, modify, merge, publish,
+ *  distribute, sublicense, and/or sell copies of the Software, and to
+ *  permit persons to whom the Software is furnished to do so, subject to
+ *  the following conditions:
+ *
+ *  The above copyright notice and this permission notice shall be
+ *  included in all copies or substantial portions of the Software.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+namespace Test {
+
+  /*
+   * Iterator for propagation kinds
+   *
+   */
+  inline
+  PropKinds::PropKinds(void) 
+    : i(sizeof(pks)/sizeof(Gecode::PropKind)-1) {}
+  inline bool 
+  PropKinds::operator()(void) const {
+    return i>=0;
+  }
+  inline void 
+  PropKinds::operator++(void) {
+    i--;
+  }
+  inline Gecode::PropKind
+  PropKinds::pk(void) const {
+    return pks[i];
+  }
+
+
+  /*
+   * Commandline options
+   *
+   */
+  inline
+  Options::Options(void)
+    : seed(0), iter(defiter), fixprob(deffixprob), reflection(true), stop(true), log(false)
+  {}
+    
+  /*
+   * Base class for tests
+   *
+   */
+  inline const std::string& 
+  Base::name(void) const {
+    return _name;
+  }
+  inline Base* 
+  Base::tests(void) {
+    return _tests;
+  }
+  inline Base* 
+  Base::next(void) const {
+    return _next;
+  }
+  inline bool
+  Base::fixpoint(void) {
+    return rand(opt.fixprob) == 0;
+  }
+
+}
+
+// STATISTICS: test-core

data/lib/gecoder/bindings.rb

@@ -1,6 +1,6 @@
 # Problems can be formulated and solved either through defining a new
-# class that inherits from Gecode::Model or by using Gecode#solve et al.
-# Gecode::Model describes how to formulate problems.
+# class that mixes in Gecode::Mixin or by using Gecode.solve et al.
+# Gecode::Mixin describes how to formulate problems.
 #
 # ==== Examples 
 #
@@ -12,9 +12,11 @@
 #   x = y - 3
 #   0 <= x,y,z <= 9
 #
-# === Inheriting from Gecode::Model
+# === Mixing in Gecode::Mixin
+#
+#   class EquationProblem 
+#     include Gecode::Mixin
 #
-#   class EquationProblem < Gecode::Model
 #     def initialize
 #       variables_is_an int_var_array(3, 0..9)
 #       x, y, z = variables
@@ -27,7 +29,7 @@
 #   end
 #   puts EquationProblem.new.solve!.variables.join(' ')
 #
-# === Using Gecode#solve
+# === Using Gecode.solve
 #
 #   solution = Gecode.solve do
 #     variables_is_an int_var_array(3, 0..9)

data/lib/gecoder/bindings/bindings.rb

@@ -1966,7 +1966,7 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
       func.add_parameter "Gecode::BoolVar", "b"
     end
     
-    ns.add_function "selectUnion" do |func|
+    ns.add_function "elementsUnion" do |func|
       func.add_parameter "Gecode::MSpace*", "home"
       func.add_parameter "Gecode::MSetVarArray", "x" do |param|
         param.custom_conversion = "*ruby2Gecode_MSetVarArrayPtr(x, 2)->ptr()"
@@ -1975,35 +1975,35 @@ Rust::Bindings::create_bindings Rust::Bindings::LangCxx, "gecode" do |b|
       func.add_parameter "Gecode::SetVar", "z"
     end
     
-    ns.add_function "selectInter" do |func|
+    ns.add_function "elementsInter" do |func|
       func.add_parameter "Gecode::MSpace*", "home"
       func.add_parameter "Gecode::MSetVarArray", "x" do |param|
-        param.custom_conversion = "*ruby2Gecode_MSetVarArrayPtr(x, 2)->ptr()"
+        param.custom_conversion = "*ruby2Gecode_MSetVarArrayPtr(argv[1], 2)->ptr()"
       end
       func.add_parameter "Gecode::SetVar", "y"
       func.add_parameter "Gecode::SetVar", "z"
     end
     
-    ns.add_function "selectInterIn" do |func|
+    ns.add_function "elementsInter" do |func|
       func.add_parameter "Gecode::MSpace*", "home"
       func.add_parameter "Gecode::MSetVarArray", "x" do |param|
-        param.custom_conversion = "*ruby2Gecode_MSetVarArrayPtr(x, 2)->ptr()"
+        param.custom_conversion = "*ruby2Gecode_MSetVarArrayPtr(argv[1], 2)->ptr()"
       end
       func.add_parameter "Gecode::SetVar", "y"
       func.add_parameter "Gecode::SetVar", "z"
       func.add_parameter "Gecode::IntSet", "universe"
     end
     
-    ns.add_function "selectSet" do |func|
+    ns.add_function "element" do |func|
       func.add_parameter "Gecode::MSpace*", "home"
       func.add_parameter "Gecode::MSetVarArray", "x" do |param|
-        param.custom_conversion = "*ruby2Gecode_MSetVarArrayPtr(x, 2)->ptr()"
+        param.custom_conversion = "*ruby2Gecode_MSetVarArrayPtr(argv[1], 2)->ptr()"
       end
       func.add_parameter "Gecode::IntVar", "y"
       func.add_parameter "Gecode::SetVar", "z"
     end
     
-    ns.add_function "selectDisjoint" do |func|
+    ns.add_function "elementsDisjoint" do |func|
       func.add_parameter "Gecode::MSpace*", "home"
       func.add_parameter "Gecode::MSetVarArray", "x" do |param|
         param.custom_conversion = "*ruby2Gecode_MSetVarArrayPtr(x, 2)->ptr()"

data/lib/gecoder/interface.rb

@@ -1,9 +1,11 @@
 require 'gecoder/interface/binding_changes'
 require 'gecoder/interface/enum_matrix'
-require 'gecoder/interface/model'
+require 'gecoder/interface/mixin'
+require 'gecoder/interface/mixin'
+require 'gecoder/interface/mixin'
 require 'gecoder/interface/search'
 require 'gecoder/interface/constraints'
 require 'gecoder/interface/variables'
 require 'gecoder/interface/enum_wrapper'
 require 'gecoder/interface/branch'
-require 'gecoder/interface/model_sugar'
+require 'gecoder/interface/convenience'

data/lib/gecoder/interface/binding_changes.rb

@@ -3,7 +3,7 @@ module GecodeRaw #:nodoc: all
   class Space
     # Used by Gecode during BAB-search.
     def constrain(best_so_far_space)
-      Gecode::Model.constrain(self, best_so_far_space)
+      Gecode::Mixin.constrain(self, best_so_far_space)
     end
   end
 end

data/lib/gecoder/interface/branch.rb

@@ -1,5 +1,5 @@
 module Gecode
-  class Model
+  module Mixin
     # Specifies which variables that should be branched on (given as an
     # enum of operands or as a single operand). One can optionally
     # also select which of the variables that should be used first with

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

@@ -5,19 +5,19 @@ module Gecode::BoolEnum #:nodoc:
   # constraints defined in BoolEnumConstraintReceiver can be placed.
   #
   # Enumerations of boolean operands can be created either by using
-  # Gecode::Model#bool_var_array and Gecode::Model#bool_var_matrix, or
+  # Gecode::Mixin#bool_var_array and Gecode::Mixin#bool_var_matrix, or
   # by wrapping an existing enumeration containing BoolOperand using
-  # Gecode::Model#wrap_enum. The enumerations, no matter how they were
+  # Gecode::Mixin#wrap_enum. The enumerations, no matter how they were
   # created, all respond to the properties defined by BoolEnumOperand.
   #
   # ==== Examples 
   #
   # Produces an array of five boolean operands inside a problem formulation
-  # using Gecode::Model#bool_var_array:
+  # using Gecode::Mixin#bool_var_array:
   #
   #   bool_enum = bool_var_array(5)
   #
-  # Uses Gecode::Model#wrap_enum inside a problem formulation to create
+  # Uses Gecode::Mixin#wrap_enum inside a problem formulation to create
   # a BoolEnumOperand from an existing enumeration containing the
   # boolean operands +bool_operand1+ and +bool_operand2+:
   #

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

@@ -5,14 +5,14 @@ module Gecode::Bool #:nodoc:
   # constraints defined in BoolConstraintReceiver can be placed.
   #
   # Boolean operands can be created either by using
-  # Gecode::Model#bool_var et al, or by using properties that produce
+  # Gecode::Mixin#bool_var et al, or by using properties that produce
   # boolean operands. The operands, no matter how they were created, 
   # all respond to the properties defined by BoolOperand.
   #
   # ==== Examples 
   #
   # Produces a single boolean operand (more specifically a BoolVar)
-  # inside a problem formulation, using Gecode::Model#bool_var:
+  # inside a problem formulation, using Gecode::Mixin#bool_var:
   #
   #   bool_operand = bool_var
   #

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

@@ -1,5 +1,5 @@
 module Gecode
-  class Model
+  module Mixin
     # Specifies an integer regexp that matches +regexp+ repeated between
     # +at_least+ and +at_most+ times (inclusive). If +at_most+ is
     # omitted then no upper bound is placed. If both +at_least+ and

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

@@ -6,12 +6,12 @@ module Gecode::FixnumEnum #:nodoc:
   # They typically service as constant arrays or constant sets.
   #
   # The fixnum enumeration operands are created by wrapping an enumeration 
-  # of fixnum Gecode::Model#wrap_enum. The enumerations created that way
+  # of fixnum Gecode::Mixin#wrap_enum. The enumerations created that way
   # all respond to the properties defined by FixnumEnumOperand.
   #
   # ==== Examples 
   #
-  # Uses Gecode::Model#wrap_enum inside a problem formulation to create
+  # Uses Gecode::Mixin#wrap_enum inside a problem formulation to create
   # a FixnumEnumOperand from an existing enumeration of Fixnum:
   #
   #   fixnum_enum = wrap_enum([3, 5, 7])

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

@@ -44,7 +44,7 @@ module Gecode::IntEnum
     # == Regexp syntax
     #
     # The regular expressions are specified using arrays, integers and a
-    # few methods provided by Model. Arrays are used to group the
+    # few methods provided by Mixin. Arrays are used to group the
     # integers in sequences that must be matched. The following array
     # describes a regular expression matching a 1 followed by a 7.
     #
@@ -55,18 +55,18 @@ module Gecode::IntEnum
     #
     #   [[[1], 7]]
     #
-    # A couple of methods provided by Model are used to express patterns 
+    # A couple of methods provided by Mixin are used to express patterns 
     # beyond mere sequences:
     #
-    # [Model#repeat] Used for specifying patterns that include patterns
+    # [Mixin#repeat] Used for specifying patterns that include patterns
     #                that may be repeated a given number of times. The 
     #                number of times to repeat a pattern can be specified 
     #                using a lower and upper bound, but the bounds can be 
     #                omitted to for instance allow an expression to be 
     #                repeated any number of times.
-    # [Model#any]    Used for specifying alternatives.
+    # [Mixin#any]    Used for specifying alternatives.
     # 
-    # Additionally Model#at_least_once and Model#at_most_once are
+    # Additionally Mixin#at_least_once and Mixin#at_most_once are
     # provided as convenience methods.
     #
     # ==== Examples 

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

@@ -5,19 +5,19 @@ module Gecode::IntEnum #:nodoc:
   # constraints defined in IntEnumConstraintReceiver can be placed.
   #
   # Enumerations of integer operands can be created either by using
-  # Gecode::Model#int_var_array and Gecode::Model#int_var_matrix, or
+  # Gecode::Mixin#int_var_array and Gecode::Mixin#int_var_matrix, or
   # by wrapping an existing enumeration containing IntOperand using
-  # Gecode::Model#wrap_enum. The enumerations, no matter how they were
+  # Gecode::Mixin#wrap_enum. The enumerations, no matter how they were
   # created, all respond to the properties defined by IntEnumOperand.
   #
   # ==== Examples 
   #
   # Produces an array of five int operands with domain 0..9 inside a 
-  # problem formulation using Gecode::Model#int_var_array:
+  # problem formulation using Gecode::Mixin#int_var_array:
   #
   #   int_enum = int_var_array(5, 0..9)
   #
-  # Uses Gecode::Model#wrap_enum inside a problem formulation to create
+  # Uses Gecode::Mixin#wrap_enum inside a problem formulation to create
   # a IntEnumOperand from an existing enumeration containing the
   # integer operands +int_operand1+ and +int_operand2+:
   #

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

@@ -5,7 +5,7 @@ module Gecode::Int #:nodoc:
   # constraints defined in IntConstraintReceiver can be placed.
   #
   # Integer operands can be created either by using
-  # Gecode::Model#int_var et al, or by using properties that produce
+  # Gecode::Mixin#int_var et al, or by using properties that produce
   # integer operands. The operands, no matter how they were created, 
   # all respond to the properties defined by IntOperand.
   #
@@ -13,7 +13,7 @@ module Gecode::Int #:nodoc:
   #
   # Produces a single integer operand (more specifically an IntVar) with
   # domain 0..9 inside a problem formulation, using
-  # Gecode::Model#int_var:
+  # Gecode::Mixin#int_var:
   #
   #   int_operand = int_var(0..9)
   #

data/lib/gecoder/interface/constraints/selected_set/select.rb

@@ -7,7 +7,7 @@ module Gecode::SelectedSet
     #   # The union of all sets selected by +set_enum[set]+.
     #   set_enum[set].union
     def union
-      Select::SelectedSetUnionOperand.new(model, self)
+      Element::SelectedSetUnionOperand.new(model, self)
     end
      
     # Produces a SetOperand representing the selected sets' intersection.
@@ -36,7 +36,7 @@ module Gecode::SelectedSet
         end
       end
       
-      Select::SelectedSetIntersectionOperand.new(model, self, universe)
+      Element::SelectedSetIntersectionOperand.new(model, self, universe)
     end
   end
 
@@ -59,11 +59,11 @@ module Gecode::SelectedSet
       end
 
       @params.update Gecode::Set::Util.decode_options(options)
-      @model.add_constraint Select::DisjointConstraint.new(@model, @params)
+      @model.add_constraint Element::DisjointConstraint.new(@model, @params)
     end
   end
 
-  module Select #:nodoc:
+  module Element #:nodoc:
     class SelectedSetUnionOperand < Gecode::Set::ShortCircuitEqualityOperand #:nodoc:
       def initialize(model, selected_set)
         super model
@@ -76,7 +76,7 @@ module Gecode::SelectedSet
           set_operand.must_be.subset_of enum.upper_bound_range
         end
         
-        Gecode::Raw::selectUnion(@model.active_space, 
+        Gecode::Raw::elementsUnion(@model.active_space, 
           enum.to_set_enum.bind_array, indices.to_set_var.bind, 
           set_operand.to_set_var.bind)
       end
@@ -97,11 +97,11 @@ module Gecode::SelectedSet
         # is the universe.
 
         if universe.nil?
-          Gecode::Raw::selectInter(@model.active_space, 
+          Gecode::Raw::elementsInter(@model.active_space, 
             enum.to_set_enum.bind_array, indices.to_set_var.bind, 
             set_operand.to_set_var.bind)
         else
-          Gecode::Raw::selectInterIn(@model.active_space,  
+          Gecode::Raw::elementsInter(@model.active_space,  
             enum.to_set_enum.bind_array, indices.to_set_var.bind, 
             set_operand.to_set_var.bind,
             Gecode::Util.constant_set_to_int_set(universe))
@@ -112,7 +112,7 @@ module Gecode::SelectedSet
     class DisjointConstraint < Gecode::Constraint #:nodoc:
       def post
         enum, indices = @params[:lhs].to_selected_set
-        Gecode::Raw.selectDisjoint(@model.active_space, 
+        Gecode::Raw.elementsDisjoint(@model.active_space, 
           enum.to_set_enum.bind_array, indices.to_set_var.bind)
       end
     end

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

@@ -0,0 +1,79 @@
+module Gecode::SetEnum
+  module SetEnumOperand
+    # This adds the adder for the methods in the modules including it. The 
+    # reason for doing it so indirect is that the first #[] won't be defined 
+    # before the module that this is mixed into is mixed into an enum.
+    def self.included(mod) #:nodoc:
+      mod.module_eval do
+        # Now we enter the module SetEnumOperands is mixed into.
+        class << self
+          alias_method :pre_set_element_included, :included
+          def included(mod) #:nodoc:
+            mod.module_eval do
+              # Now we enter the module that the module possibly defining #[] 
+              # is mixed into.
+              if instance_methods.include?('[]') and 
+                  not instance_methods.include?('pre_set_element_access')
+                alias_method :pre_set_element_access, :[]
+              end
+            
+              # Produces a SetOperand representing the i:th set
+              # operand in the enumeration, where i is the value of the
+              # int operand used as index. 
+              #
+              # A set can also be used as index, in which case a
+              # SelectedSetOperand is produced.
+              #
+              # ==== Examples 
+              # 
+              #   # The set operand at the +x+:th position in +set_enum+,
+              #   # where +x+ is a int operand.  
+              #   set_enum[x]
+              #
+              #   # The SelectedSetOperand representing sets at positions
+              #   # included in the value of +set+ in +set_enum+,
+              #   set_enum[set]
+              #
+              def [](*vars)
+                # Hook in an element constraint if a operand is used for array 
+                # access.
+                if vars.first.respond_to? :to_int_var
+                  Element::ElementSetOperand.new(
+                    model, self, vars.first)
+                elsif vars.first.respond_to? :to_set_var
+                  Gecode::SelectedSet::SelectedSetOperand.new(
+                    self, vars.first)
+                else
+                  if respond_to? :pre_set_element_access
+                    pre_set_element_access(*vars) 
+                  end
+                end
+              end
+            end
+            pre_set_element_included(mod)
+          end
+        end
+      end
+    end
+  end
+
+  module Element #:nodoc:
+    class ElementSetOperand < Gecode::Set::ShortCircuitEqualityOperand #:nodoc:
+      def initialize(model, enum_op, position_int_op)
+        super model
+        @enum = enum_op
+        @position = position_int_op
+      end
+
+      def constrain_equal(set_operand, constrain, propagation_options)
+        enum = @enum.to_set_enum
+        if constrain
+          set_operand.must_be.subset_of enum.upper_bound_range
+        end
+
+        Gecode::Raw::element(@model.active_space, enum.bind_array, 
+          @position.to_int_var.bind, set_operand.to_set_var.bind)
+      end
+    end
+  end 
+end