dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/flatzinc/registry.hh

@@ -0,0 +1,71 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2007
+ *
+ *  Last modified:
+ *     $Date: 2009-09-10 19:44:51 +1000 (Thu, 10 Sep 2009) $ by $Author: tack $
+ *     $Revision: 9700 $
+ *
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_FLATZINC_REGISTRY_HH__
+#define __GECODE_FLATZINC_REGISTRY_HH__
+
+#include <gecode/flatzinc.hh>
+#include <string>
+#include <map>
+
+namespace Gecode { namespace FlatZinc {
+
+  /// Map from constraint identifier to constraint posting functions
+  class Registry {
+  public:
+    /// Type of constraint posting function
+    typedef void (*poster) (FlatZincSpace&,
+                            const ConExpr&,
+                            AST::Node*);
+    /// Add posting function \a p with identifier \a id
+    void add(const std::string& id, poster p);
+    /// Post constraint specified by \a ce
+    void post(FlatZincSpace& s, const ConExpr& ce, AST::Node* ann);
+
+  private:
+    /// The actual registry
+    std::map<std::string,poster> r;
+  };
+  
+  /// Return global registry object
+  Registry& registry(void);
+
+}}
+
+#endif
+
+// STATISTICS: flatzinc-any

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/flatzinc/symboltable.hh

@@ -0,0 +1,96 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2007
+ *
+ *  Last modified:
+ *     $Date: 2010-07-29 00:43:32 +1000 (Thu, 29 Jul 2010) $ by $Author: tack $
+ *     $Revision: 11293 $
+ *
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_FLATZINC_SYMBOLTABLE_HH__
+#define __GECODE_FLATZINC_SYMBOLTABLE_HH__
+
+#include <vector>
+
+#ifdef GECODE_HAS_GNU_HASH_MAP
+#include <ext/hash_map>
+#else
+#include <map>
+#endif
+
+namespace Gecode { namespace FlatZinc {
+
+  /// Symbol table mapping identifiers (strings) to values
+  template<class Val>
+  class SymbolTable {
+  private:
+#ifdef GECODE_HAS_GNU_HASH_MAP
+    class hashString {
+    public:
+      size_t operator ()(const std::string& x) const {
+        return __gnu_cxx::hash<const char*>()(x.c_str());
+      }
+    };
+    typedef __gnu_cxx::hash_map<std::string,Val,hashString> mymap;
+#else
+    typedef std::map<std::string,Val> mymap;
+#endif
+    mymap m;
+  public:
+    /// Insert \a val with \a key
+    bool put(const std::string& key, const Val& val);
+    /// Return whether \a key exists, and set \a val if it does exist
+    bool get(const std::string& key, Val& val) const;
+  };
+
+  template<class Val>
+  bool
+  SymbolTable<Val>::put(const std::string& key, const Val& val) {
+    typename mymap::const_iterator i = m.find(key);
+    bool fresh = (i == m.end());
+    m[key] = val;
+    return fresh;
+  }
+
+  template<class Val>
+  bool
+  SymbolTable<Val>::get(const std::string& key, Val& val) const {
+    typename mymap::const_iterator i = m.find(key);
+    if (i == m.end())
+      return false;
+    val = i->second;
+    return true;
+  }
+
+}}
+#endif
+
+// STATISTICS: flatzinc-any

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/flatzinc/varspec.hh

@@ -0,0 +1,163 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2007
+ *
+ *  Last modified:
+ *     $Date: 2010-04-08 19:25:15 +1000 (Thu, 08 Apr 2010) $ by $Author: tack $
+ *     $Revision: 10682 $
+ *
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_FLATZINC_VARSPEC__HH__
+#define __GECODE_FLATZINC_VARSPEC__HH__
+
+#include <gecode/flatzinc/option.hh>
+#include <gecode/flatzinc/ast.hh>
+#include <vector>
+#include <iostream>
+
+namespace Gecode { namespace FlatZinc {
+
+  /// %Alias for a variable specification
+  class Alias {
+  public:
+    const int v;
+    Alias(int v0) : v(v0) {}
+  };
+
+  /// Base class for variable specifications
+  class VarSpec {
+  public:
+    /// Whether the variable was introduced in the mzn2fzn translation
+    bool introduced;
+    /// Destructor
+    virtual ~VarSpec(void) {}
+    /// Variable index
+    int i;
+    /// Whether the variable aliases another variable
+    bool alias;
+    /// Whether the variable is assigned
+    bool assigned;
+    /// Constructor
+    VarSpec(bool introduced0) : introduced(introduced0) {}
+  };
+
+  /// Specification for integer variables
+  class IntVarSpec : public VarSpec {
+  public:
+    Option<AST::SetLit* > domain;
+    IntVarSpec(const Option<AST::SetLit* >& d, bool introduced)
+    : VarSpec(introduced) {
+      alias = false;
+      assigned = false;
+      domain = d;
+    }
+    IntVarSpec(int i0, bool introduced) : VarSpec(introduced) {
+      alias = false; assigned = true; i = i0;
+    }
+    IntVarSpec(const Alias& eq, bool introduced) : VarSpec(introduced) {
+      alias = true; i = eq.v;
+    }
+    ~IntVarSpec(void) {
+      if (!alias && !assigned && domain())
+        delete domain.some();
+    }
+  };
+
+  /// Specification for Boolean variables
+  class BoolVarSpec : public VarSpec {
+  public:
+    Option<AST::SetLit* > domain;
+    BoolVarSpec(Option<AST::SetLit* >& d, bool introduced)
+    : VarSpec(introduced) {
+      alias = false; assigned = false; domain = d;
+    }
+    BoolVarSpec(bool b, bool introduced) : VarSpec(introduced) {
+      alias = false; assigned = true; i = b;
+    }
+    BoolVarSpec(const Alias& eq, bool introduced) : VarSpec(introduced) {
+      alias = true; i = eq.v;
+    }
+    ~BoolVarSpec(void) {
+      if (!alias && !assigned && domain())
+        delete domain.some();
+    }
+  };
+
+  /// Specification for floating point variables
+  class FloatVarSpec : public VarSpec {
+  public:
+    Option<std::vector<double>* > domain;
+    FloatVarSpec(Option<std::vector<double>* >& d, bool introduced)
+    : VarSpec(introduced) {
+      alias = false; assigned = false; domain = d;
+    }
+    FloatVarSpec(bool b, bool introduced) : VarSpec(introduced) {
+      alias = false; assigned = true; i = b;
+    }
+    FloatVarSpec(const Alias& eq, bool introduced) : VarSpec(introduced) {
+      alias = true; i = eq.v;
+    }
+    ~FloatVarSpec(void) {
+      if (!alias && !assigned && domain())
+        delete domain.some();
+    }
+  };
+
+  /// Specification for set variables
+  class SetVarSpec : public VarSpec {
+  public:
+    Option<AST::SetLit*> upperBound;
+    SetVarSpec(bool introduced) : VarSpec(introduced) {
+      alias = false; assigned = false;
+      upperBound = Option<AST::SetLit* >::none();
+    }
+    SetVarSpec(const Option<AST::SetLit* >& v, bool introduced)
+    : VarSpec(introduced) {
+      alias = false; assigned = false; upperBound = v;
+    }
+    SetVarSpec(AST::SetLit* v, bool introduced) : VarSpec(introduced) {
+      alias = false; assigned = true;
+      upperBound = Option<AST::SetLit*>::some(v);
+    }
+    SetVarSpec(const Alias& eq, bool introduced) : VarSpec(introduced) {
+      alias = true; i = eq.v;
+    }
+    ~SetVarSpec(void) {
+      if (!alias && upperBound())
+        delete upperBound.some();
+    }
+  };
+
+}}
+
+#endif
+
+// STATISTICS: flatzinc-any

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/gist.hh

@@ -0,0 +1,298 @@
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2011-08-25 18:43:31 +1000 (Thu, 25 Aug 2011) $ by $Author: tack $
+ *     $Revision: 12352 $
+ *
+ *  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.
+ *
+ */
+
+#ifndef __GECODE_GIST_HH__
+#define __GECODE_GIST_HH__
+
+#include <gecode/kernel.hh>
+#include <gecode/search.hh>
+#include <gecode/int.hh>
+#ifdef GECODE_HAS_SET_VARS
+#include <gecode/set.hh>
+#endif
+
+/*
+ * Configure linking
+ *
+ */
+
+#if !defined(GIST_STATIC_LIBS) && \
+    (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))
+
+#ifdef GECODE_BUILD_GIST
+#define GECODE_GIST_EXPORT __declspec( dllexport )
+#else
+#define GECODE_GIST_EXPORT __declspec( dllimport )
+#endif
+
+#else
+
+#ifdef GECODE_GCC_HAS_CLASS_VISIBILITY
+#define GECODE_GIST_EXPORT __attribute__ ((visibility("default")))
+#else
+#define GECODE_GIST_EXPORT
+#endif
+
+#endif
+
+// Configure auto-linking
+#ifndef GECODE_BUILD_GIST
+#define GECODE_LIBRARY_NAME "Gist"
+#include <gecode/support/auto-link.hpp>
+#endif
+
+#include <string>
+#include <sstream>
+
+namespace Gecode {
+
+  /**
+   * \namespace Gecode::Gist
+   * \brief The %Gecode Interactive %Search Tool
+   *
+   * The Gecode::Gist namespace contains the %Gecode Interactive %Search Tool,
+   * a Qt-based graphical search engine.
+   *
+   */
+  namespace Gist {
+
+    /** \brief Abstract base class for inspectors
+     *
+     * An inspector provides a virtual method that is called
+     * when a node in the search tree is inspected (e.g. by
+     * double-clicking)
+     *
+     * \ingroup TaskGist
+     */
+    class GECODE_GIST_EXPORT Inspector {
+    public:
+      /// Call-back function
+      virtual void inspect(const Space& s) = 0;
+      /// Name of the inspector
+      virtual std::string name(void);
+      /// Clean up when Gist exits
+      virtual void finalize(void);
+      /// Destructor
+      virtual ~Inspector(void);
+    };
+
+    /** \brief Abstract base class for comparators
+     *
+     * A comparator provides a virtual method that is called
+     * when a node in the search tree is compared to another
+     * node.
+     *
+     * \ingroup TaskGist
+     */
+    class GECODE_GIST_EXPORT Comparator {
+    public:
+      //@{
+      ///\name Comparator interface
+      
+      /// Call-back function
+      virtual void compare(const Space& s0, const Space& s1) = 0;
+      /// Name of the comparator
+      virtual std::string name(void);
+      /// Clean up when Gist exits
+      virtual void finalize(void);
+      /// Destructor
+      virtual ~Comparator(void);
+
+      //@}
+
+      //@{
+      ///\name Helper methods
+      
+      /// Return string representation of difference between arrays \a x and \a y, which are called \a x_n
+      template<class Var>
+      static std::string compare(std::string x_n, const VarArgArray<Var>& x,
+        const VarArgArray<Var>& y);
+      /// Return string representation of difference between \a x and \a y, which are called \a x_n
+      static std::string compare(std::string x_n, IntVar x, IntVar y);
+      /// Return string representation of difference between \a x and \a y, which are called \a x_n
+      static std::string compare(std::string x_n, BoolVar x, BoolVar y);
+#ifdef GECODE_HAS_SET_VARS
+      /// Return string representation of difference between \a x and \a y, which are called \a x_n
+      static std::string compare(std::string x_n, SetVar x, SetVar y);
+#endif
+      //@}
+    };
+        
+    class TextOutputI;
+    
+    /// An window for simple text output
+    class GECODE_GIST_EXPORT TextOutput {
+    private:
+      /// The implementation object
+      TextOutputI *t;
+      /// The name of the window
+      std::string n;
+    protected:
+      /// Initialize the implementation object
+      void init(void);
+      /// Get the stream that is used to output text
+      std::ostream& getStream(void);
+      /// Flush stream
+      void flush(void);
+      /// Add html text \a s to the output
+      void addHtml(const char* s);
+    public:
+      /// Constructor
+      TextOutput(const std::string& name);
+      /// Clean up when Gist exits
+      void finalize(void);
+      /// Destructor
+      virtual ~TextOutput(void);
+      /// Name of the inspector
+      virtual std::string name(void);
+    };
+    
+    /// An inspector for printing simple text output
+    template<class S>
+    class Print : public TextOutput, public Inspector {
+    public:
+      /// Constructor
+      Print(const std::string& name);
+      /// Use the print method of the template class S to print a space
+      virtual void inspect(const Space& node);
+      /// Return name
+      virtual std::string name(void);
+      /// Clean up when Gist exits
+      virtual void finalize(void);
+    };
+
+    /**
+     * \brief A simple comparator
+     *
+     * This class serves two purposes. First, it provides static methods
+     * that compare two variables or two arrays of variables and return
+     * a string representation of the differences.
+     * Second, it implements a Comparator that uses the compare method of
+     * the script to output the differences between two spaces.
+     *
+     */
+    template<class S>
+    class VarComparator : public TextOutput, public Comparator {
+    public:
+      /// Constructor
+      VarComparator(std::string name);
+      /// Compare \a s0 to \a s1
+      virtual void compare(const Space& s0, const Space& s1);
+      /// Return name
+      virtual std::string name(void);
+      /// Finalize when Gist exits
+      virtual void finalize(void);
+    };
+    
+    /// A branching that stops exploration
+    GECODE_GIST_EXPORT
+    void stopBranch(Space& home);
+    
+    /**
+     * \brief %Options for %Gist
+     *
+     * Note that the \a d and \a stop fields of the Search::Options class
+     * are not used by Gist.
+     *
+     */
+    class Options : public Search::Options {
+    public:
+      /// Helper class storing inspectors
+      class _I {
+      private:
+        Support::DynamicArray<Inspector*,Heap> _click;
+        unsigned int n_click;
+        Support::DynamicArray<Inspector*,Heap> _solution;
+        unsigned int n_solution;
+        Support::DynamicArray<Inspector*,Heap> _move;
+        unsigned int n_move;
+        Support::DynamicArray<Comparator*,Heap> _compare;
+        unsigned int n_compare;
+      public:
+        /// Constructor
+        _I(void);
+        /// Add inspector that reacts on node double clicks
+        void click(Inspector* i);
+        /// Add inspector that reacts on each new solution that is found
+        void solution(Inspector* i);
+        /// Add inspector that reacts on each move of the cursor
+        void move(Inspector* i);
+        /// Add comparator
+        void compare(Comparator* c);
+        
+        /// Return click inspector number \a i, or NULL if it does not exist
+        Inspector* click(unsigned int i) const;
+        /// Return solution inspector number \a i, or NULL if it does not exist
+        Inspector* solution(unsigned int i) const;
+        /// Return move inspector number \a i, or NULL if it does not exist
+        Inspector* move(unsigned int i) const;
+        /// Return comparator number \a i, or NULL if it does not exist
+        Comparator* compare(unsigned int i) const;
+      } inspect;
+      /// Default options
+      GECODE_GIST_EXPORT static const Options def;
+      /// Initialize with default values
+      Options(void);
+    };
+
+    
+    /// Create a new stand-alone Gist for \a root using \a bab
+    GECODE_GIST_EXPORT int 
+    explore(Space* root, bool bab, const Options& opt);
+    
+    /**
+     * \brief Create a new stand-alone Gist for \a root
+     * \ingroup TaskGist
+     */
+    int 
+    dfs(Space* root, const Gist::Options& opt = Gist::Options::def);
+    
+    /**
+     * \brief Create a new stand-alone Gist for branch-and-bound search of \a root
+     * \ingroup TaskGist
+     */
+    int 
+    bab(Space* root, const Gist::Options& opt = Gist::Options::def);
+    
+  }	
+
+}
+
+#include <gecode/gist/gist.hpp>
+
+#endif
+
+// STATISTICS: gist-any