gecoder-with-gecode 0.9.0 → 0.9.1

data/ext/gecode-2.1.1/gecode/set/projectors.hh

@@ -1,438 +0,0 @@
-/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
-/*
- *  Main authors:
- *     Guido Tack <tack@gecode.org>
- *
- *  Contributing authors:
- *     Christian Schulte <schulte@gecode.org>
- *
- *  Copyright:
- *     Guido Tack, 2006
- *     Christian Schulte, 2007
- *
- *  Last modified:
- *     $Date: 2008-02-27 18:06:13 +0100 (Wed, 27 Feb 2008) $ by $Author: tack $
- *     $Revision: 6332 $
- *
- *  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_GENERATOR_PROJECOTRS_HH
-#define __GECODE_GENERATOR_PROJECTORS_HH
-
-#include "gecode/set.hh"
-
-namespace Gecode {
-
-  /**
-   * \defgroup TaskModelSetProjector Projector constraints
-   * \ingroup TaskModelSet
-   *
-   */
-
-  //@{
-
-  /**
-   * \brief Code representing set-valued expressions for finite set projectors
-   *
-   * Set-valued expressions are represented using a simple stack-based
-   * language.
-   */
-  class SetExprCode {
-  private:
-    /// The actual instructions
-    SharedArray<int> c;
-  public:
-    /// Instructions for set-valued expression code
-    enum Instruction {
-      COMPLEMENT, ///< Complement
-      INTER,      ///< Intersection
-      UNION,      ///< Union
-      GLB,        ///< Greatest lower bound
-      LUB,        ///< Least upper bound
-      EMPTY,      ///< Constant empty set
-      UNIVERSE,   ///< Constant universal set
-      LAST        ///< First integer to use for immediate arguments
-    };
-
-    /// To incrementally build up the instructions
-    class Stream {
-    private:
-      /// Instruction stream
-      Support::DynamicArray<int> is;
-      /// Current instruction
-      int n;
-    public:
-      /// Initialize stream to be empty
-      Stream(void);
-      /// Add instruction or variable reference to stream
-      void add(int i);
-      /// Return size of code stream
-      int size(void) const;
-      /// Return instruction at position \a i
-      int operator[](int i) const;
-    };
- 
-    ///\name Construction and initialization
-    //@{
-    /// Default constructor
-    SetExprCode(void);
-    /// Construct from code Stream
-    SetExprCode(const Stream& s);
-    /// Copy constructor
-    SetExprCode(const SetExprCode& sc);
-    //@}
-
-    /// Copying
-    void update(Space* home, bool share, SetExprCode& sc);
-    
-    /// Return number of instructions
-    int size(void) const;
-
-    /// Return instruction at position \a i
-    int operator[](int i) const;
-
-  };
-  
-  /**
-   * \brief Set-valued expressions for finite set projectors
-   */
-  class SetExpr {
-  public:
-    /// Type of variable indices
-    typedef int var_idx;
-
-    /// Relation used to connect two set expressions
-    enum RelType {
-      REL_INTER, ///< Intersection relation
-      REL_UNION  ///< Union relation
-    };
-    
-  private:
-    /// Nodes for set expressions
-    class Node;
-
-    Node* ax; ///< Node for expression
-    int sign; ///< Sign for expression
-  public:
-
-    /// Construct constant set expression for the empty set
-    SetExpr(void);
-    /// Copy constructor
-    GECODE_SET_EXPORT SetExpr(const SetExpr& s);
-    /// Construct set expression for variable \a v
-    GECODE_SET_EXPORT SetExpr(var_idx v);
-    /// Construct set expression from \a s with sign \a sign
-    GECODE_SET_EXPORT SetExpr(const SetExpr& s, int sign);
-    /// Construct set expression from \a s with sign \a ssign and \a t with sign \a tsign under relation \a r
-    GECODE_SET_EXPORT SetExpr(const SetExpr& s, int ssign,
-                              RelType r,
-                              const SetExpr& t, int tsign);
-    /// Assignment operator
-    GECODE_SET_EXPORT const SetExpr& operator=(const SetExpr& e);
-    /// Returns the arity of the set expression
-    GECODE_SET_EXPORT int arity(void) const;
-    /// Returns code for this set expression
-    GECODE_SET_EXPORT SetExprCode encode(void) const;
-    /// Destructor
-    GECODE_SET_EXPORT ~SetExpr(void);
-  };
-
-}
-
-///\name Specifying finite set projectors
-//@{
-
-/// Return set expression for the complement of \a s
-Gecode::SetExpr operator-(const Gecode::SetExpr& s);
-/// Return set expression for the union of \a s and \a t
-Gecode::SetExpr operator||(const Gecode::SetExpr& s,
-                           const Gecode::SetExpr& t);
-/// Return set expression for the intersection of \a s and \a t
-Gecode::SetExpr operator&&(const Gecode::SetExpr& s,
-                           const Gecode::SetExpr& t);
-/// Return set expression for the difference of \a s and \a t
-Gecode::SetExpr operator-(const Gecode::SetExpr& s,
-                          const Gecode::SetExpr& t);
-
-///@}
-
-namespace Gecode {
-
-  /**
-   * \brief Finite set projector specification
-   */
-  class Projector {
-  private:
-    SetExpr::var_idx i; ///< The variable for this projector
-    SetExprCode glb; ///< The greatest lower bound set expression code
-    SetExprCode lub; ///< The least upper bound set expression code
-    int _arity; ///< The arity of this projector
-  public:
-    /// Default constructor
-    Projector(void);
-    /// Construct a projector \f$(\mathrm{sglb}\subseteq x\subseteq\mathrm{slub})\f$
-    Projector(SetExpr::var_idx x, const SetExpr& sglb, const SetExpr& slub);
-
-    /// Returns the scope of the projector
-    GECODE_SET_EXPORT void scope(Support::DynamicArray<int>& scope) const;
-
-    /// Returns the arity of the projector
-    GECODE_SET_EXPORT int arity(void) const;
-              
-    /// Propagate the projector
-    template <bool negated>
-    ExecStatus propagate(Space* home, ViewArray<Set::SetView>& x);
-
-    /// Check for subsumption or failure
-    GECODE_SET_EXPORT ExecStatus check(Space* home,
-                                       ViewArray<Set::SetView>& x);
-
-    /// Compute size of greatest lower bound
-    unsigned int glbSize(ViewArray<Set::SetView>& x);
-    
-    /// Compute size of least upper bound
-    unsigned int lubSize(ViewArray<Set::SetView>& x);
-
-    /// Return the set expression code for the glb
-    const SetExprCode& getGlb(void) const;
-
-    /// Return the set expression code for the lub
-    const SetExprCode& getLub(void) const;
-
-    /// Return the variable index for this projector
-    SetExpr::var_idx getIdx(void) const;
-
-  };
-  
-  /**
-   * \brief Group of finite set projector specifications
-   */
-  class ProjectorSet {
-  private:
-    SharedArray<Projector> _ps; ///< The projectors
-    int _count; ///< The number of projectors in the set
-    int _arity; ///< The maximum arity of the projectors in the set
-    
-  public:
-    
-    /// Construct empty projector set
-    ProjectorSet(void);
-    
-    /// Construct projector set for \a n projectors
-    ProjectorSet(int n);
-
-    /// Used for copying
-    void update(Space* home, bool share, ProjectorSet& p);
-
-    /// Add projector \a p to the set
-    GECODE_SET_EXPORT void add(const Projector& p);
-
-    /// Returns the arity of the projector set
-    int arity(void) const;
-
-    /// Returns the scope of the projector set
-    GECODE_SET_EXPORT void scope(Support::DynamicArray<int>& scope,
-                                 unsigned int size) const;
-    
-    /// Propagate the set
-    template <bool negated>
-    ExecStatus propagate(Space* home, ViewArray<Set::SetView>& x);
-
-    /// Check for subsumption or failure
-    GECODE_SET_EXPORT ExecStatus check(Space* home,
-                                       ViewArray<Set::SetView>& x);
-
-    /// Return number of projectors int the set
-    int size(void) const;
-
-    /// Return projector \a i from the set
-    const Projector& operator[](int i) const;
-
-  };
-
-  ///\name Formulas for specifying set constraints
-  //@{
-
-  /// Formulas for specifying set constraints
-  class Formula {
-  public:
-    enum Operator { AND, OR, IMPL, EQUIV };
-  private:
-    /// Nodes for formulas
-    class Node;
-    Node* ax; ///< Node for formula
-    int sign; ///< Sign for formula
-  public:
-    /// Copy constructor
-    GECODE_SET_EXPORT Formula(const Formula& f);
-    /// Assignment operator
-    GECODE_SET_EXPORT const Formula& operator=(const Formula& f);
-    /// Destructor
-    GECODE_SET_EXPORT ~Formula(void);
-    /// Construct formula for variable \a var
-    GECODE_SET_EXPORT Formula(int var);
-    /// Construct constant formula
-    GECODE_SET_EXPORT Formula(bool b);
-    /// Construct formula from \a f with sign \a s
-    GECODE_SET_EXPORT Formula(const Formula& f, int sign);
-    /// Construct formula for \f$\mathit{fs}\times f\mathit{op} \mathit{gs}\times g\f$
-    GECODE_SET_EXPORT Formula(const Formula& f, int fs,
-                              Operator r,
-                              const Formula& g, int gs);
-    /// Extract projectors from formula
-    GECODE_SET_EXPORT ProjectorSet projectors(void);
-    
-  };
-
-}
-
-///\name Operations on formulas for specifying set constraints
-//@{
-
-/// Return formula \f$f\land g\f$ \relates Formula
-Gecode::Formula operator&(const Gecode::Formula& f, const Gecode::Formula& g);
-/// Return formula \f$f\lor g\f$ \relates Formula
-Gecode::Formula operator|(const Gecode::Formula& f, const Gecode::Formula& g);
-/// Return formula \f$\lnot f\f$ \relates Formula
-Gecode::Formula operator-(const Gecode::Formula& f);
-/// Return formula \f$f\rightarrow f\f$ \relates Formula
-Gecode::Formula operator>>(const Gecode::Formula& f,
-                           const Gecode::Formula& g);
-/// Return formula \f$f\leftrightarrow g\f$ \relates Formula
-Gecode::Formula operator==(const Gecode::Formula& f,
-                           const Gecode::Formula& g);
-
-//@}
-
-namespace Gecode {
-  
-  ///\name Posting projection propagators
-  //@{
-
-  /**
-   * \brief Post projection propagators for nary constraint
-   *
-   * Post projection propagators for nary constraint on variables
-   * \a x, specified by \a ps. If \a negated is true, the
-   * negation of the specified constraint is propagated.
-   */
-  GECODE_SET_EXPORT void
-  projector(Space* home, const SetVarArgs& xa,
-            ProjectorSet& ps, bool negated=false);
-
-  /**
-   * \brief Post projection propagators for binary constraint
-   *
-   * Post projection propagators for binary constraint on variables
-   * \a xa and \a ya, specified by \a ps. If \a negated is true, the
-   * negation of the specified constraint is propagated.
-   */
-  GECODE_SET_EXPORT void
-  projector(Space* home, const SetVar& xa, const SetVar& ya,
-            ProjectorSet& ps, bool negated=false);
-
-  /**
-   * \brief Post reified projection propagators for binary constraint
-   *
-   * Post projection propagators for binary constraint on variables
-   * \a xa and \a ya, specified by \a ps, reified with \a bv.
-   */
-  GECODE_SET_EXPORT void
-  projector(Space* home, const SetVar& xa, const SetVar& ya,
-            const BoolVar& bv,
-            ProjectorSet& ps);
-
-  /**
-   * \brief Post projection propagators for ternary constraint
-   *
-   * Post projection propagators for ternary constraint on variables
-   * \a xa, \a ya and \a za, specified by \a ps. If \a negated is true, the
-   * negation of the specified constraint is propagated.
-   */
-  GECODE_SET_EXPORT void
-  projector(Space* home,
-            const SetVar& xa, const SetVar& ya, const SetVar& za,
-            ProjectorSet& ps, bool negated=false);
-
-  /**
-   * \brief Post reified projection propagators for ternary constraint
-   *
-   * Post projection propagators for ternary constraint on variables
-   * \a xa, \a ya and \a za, specified by \a ps, reified with \a bv.
-   */
-  GECODE_SET_EXPORT void
-  projector(Space* home,
-            const SetVar& xa, const SetVar& ya, const SetVar& za,
-            const BoolVar& bv,
-            ProjectorSet& ps);
-  
-  /**
-   * \brief Post projection propagator for cardinality constraint
-   *
-   * Post propagator for the constraint that \a i is the
-   * cardinality of the set represented by \a p, interpreted over the
-   * variables \a xa and \a ya.
-   */
-  GECODE_SET_EXPORT void
-  projector(Space* home, const SetVar& xa, const SetVar& ya,
-            const IntVar& i,
-            Projector& p);
-
-  /**
-   * \brief Post projection propagator for cardinality constraint
-   *
-   * Post propagator for the constraint that \a i is the
-   * cardinality of the set represented by \a p, interpreted over the
-   * variables \a xa, \a ya, and \a za.
-   */
-  GECODE_SET_EXPORT void
-  projector(Space* home, const SetVar& xa, const SetVar& ya,
-            const SetVar& za, const IntVar& i,
-            Projector& p);
-
-  //@}
-
-  //@}
-
-}
-
-GECODE_SET_EXPORT std::ostream&
-operator<<(std::ostream&, const Gecode::SetExprCode& sec);
-
-GECODE_SET_EXPORT std::ostream&
-operator<<(std::ostream&, const Gecode::Projector& p);
-
-GECODE_SET_EXPORT std::ostream&
-operator<<(std::ostream&, const Gecode::ProjectorSet& ps);
-
-#include "gecode/set/projectors/set-expr.icc"
-#include "gecode/set/projectors/projector.icc"
-#include "gecode/set/projectors/projector-set.icc"
-#include "gecode/set/projectors/formula.icc"
-
-#endif
-
-// STATISTICS: set-prop

data/ext/gecode-2.1.1/gecode/set/projectors/formula.cc

@@ -1,312 +0,0 @@
-/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
-/*
- *  Main authors:
- *     Guido Tack <tack@gecode.org>
- *
- *  Copyright:
- *     Guido Tack, 2006
- *
- *  Last modified:
- *     $Date: 2008-01-25 15:19:57 +0100 (Fri, 25 Jan 2008) $ by $Author: tack $
- *     $Revision: 5986 $
- *
- *  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.
- *
- */
-
-#include "gecode/set/projectors.hh"
-
-#include "gecode/support/buddy/bdd.h"
-#include <set>
-
-using namespace Gecode::Set;
-
-namespace Gecode {
-
-  /**
-   * \brief Nodes used to construct formulas
-   */
-  class Formula::Node {
-  private:
-    /// Nodes are reference counted
-    unsigned int use;
-    /// Left and right subtrees
-    Node *left, *right;
-    /// Left and right signs for entire subtress
-    int signLeft, signRight;
-    /// Variable
-    int x;
-    /// Relation
-    Operator r;
-    /// Collect free variables of the formula
-    void fv(std::set<int>& s);
-  public:
-    /// Construct node for \a x
-    Node(const int x);
-    /// Construct node from nodes \a n0 and \a n1 with signs \a s0 and \a s1
-    Node(Node* n0, int s0, Operator r, Node* n1, int s1);
-    
-    /// Increment reference count
-    void increment(void);
-    /// Decrement reference count and possibly free memory
-    bool decrement(void);
-
-    /// Return free variables of the formula
-    std::set<int> fv(void);
-    /// Transform formula into bdd
-    bdd toBdd(void);
-    
-    /// Memory management
-    static void* operator new(size_t size);
-    /// Memory management
-    static void  operator delete(void* p,size_t size);
-  };
-
-  /*
-   * Operations for nodes
-   *
-   */
-
-  forceinline void*
-  Formula::Node::operator new(size_t size) {
-    return Memory::malloc(size);
-  }
-
-  forceinline void
-  Formula::Node::operator delete(void* p, size_t) {
-    Memory::free(p);
-  }
-
-
-  forceinline void
-  Formula::Node::increment(void) { 
-    ++use; 
-  }
-
-  forceinline
-  Formula::Node::Node(const int x) :
-    use(1),
-    left(NULL), right(NULL), signLeft(0), signRight(0), x(x) {}
-
-  forceinline
-  Formula::Node::Node(Node* l, int sL, Operator _r, Node* r, int sR) :
-    use(1),
-    left(l), right(r), signLeft(sL), signRight(sR), r(_r) {
-    if (left != NULL)
-      left->increment();
-    if (right != NULL)
-      right->increment();
-  }
-
-  bool
-  Formula::Node::decrement(void) {
-    if (--use == 0) {
-      if (left != NULL && left->decrement())
-	      delete left;
-      if (right != NULL && right->decrement())
-	      delete right;
-      return true;
-    }
-    return false;
-  }
-
-  void
-  Formula::Node::fv(std::set<int>& s) {
-    if (left==NULL)
-      s.insert(x);
-    else {
-      left->fv(s);
-      right->fv(s);
-    }
-  }
-  
-  inline
-  std::set<int>
-  Formula::Node::fv(void) {
-    std::set<int> s;
-    fv(s);
-    return s;
-  }
-
-  bdd
-  Formula::Node::toBdd(void) {
-    if (left==NULL) {
-      return bdd_ithvar(x);
-    } else {
-      bdd bl = left->toBdd(); bdd br = right->toBdd();
-      if (signLeft == -1)
-	bl = !bl;
-      if (signRight == -1)
-	br = !br;
-      
-      switch (r) {
-      case OR:
-        return bl | br;
-      case AND:
-        return bl & br;
-      case IMPL:
-        return bl >> br;
-      case EQUIV:
-        return (bl >> br) & (br >> bl);
-      default:
-        assert(false);
-        return bdd_false();
-      }
-    }
-  }
-
-  /*
-   * Operations for formulas
-   *
-   */
-  
-  Formula::Formula(int v) : ax(new Node(v)), sign(1) {}
-
-  Formula::Formula(const Formula& f, int sf,
-                   Operator r,
-                   const Formula& g, int sg)
-    : ax(new Node(f.ax,f.sign*sf,r,g.ax,g.sign*sg)), sign(1) {}
-
-  Formula::Formula(const Formula& f, int sign)
-    : ax(f.ax), sign(f.sign*sign) {
-    if (ax != NULL)
-      ax->increment();
-  }
-
-  Formula::Formula(const Formula& f)
-    : ax(f.ax), sign(f.sign) {
-    if (ax != NULL)
-      ax->increment();
-  }
-
-  const Formula&
-  Formula::operator=(const Formula& f) {
-    if (this != &f) {
-      if ((ax != NULL) && ax->decrement())
-        delete ax;
-      ax = f.ax;
-      sign = f.sign;
-      if (ax != NULL)
-        ax->increment();
-    }
-    return *this;
-  }
-
-  Formula::~Formula(void) {
-    if ((ax != NULL) && ax->decrement())
-      delete ax;
-  }
-
-  namespace {
-
-    /// Translate \a b into a SetExpr
-    SetExpr bddToSetExpr(const bdd& b) {
-      if (b == bdd_true())
-        return SetExpr(SetExpr(), -1);
-      else if (b == bdd_false())
-        return SetExpr();
-
-      SetExpr right = bddToSetExpr(bdd_high(b));
-      SetExpr left = bddToSetExpr(bdd_low(b));
-
-      SetExpr selfRight, selfLeft;
-
-      int var = bdd_var(b);
-
-      if (bdd_high(b) == bdd_true()) {
-        selfRight = SetExpr(var);
-        selfLeft = left;
-      } else if (bdd_low(b) == bdd_true()) {
-        selfLeft = SetExpr(SetExpr(var), -1);
-        selfRight = right;
-      } else {
-        selfRight = SetExpr(var) && right;
-        selfLeft = SetExpr(SetExpr(var), -1) && left;
-      }
-
-      if (bdd_high(b) == bdd_false())
-        return selfLeft;
-      if (bdd_low(b) == bdd_false())
-        return selfRight;
-    
-      return selfLeft || selfRight;
-    }
-
-  }
-
-  ProjectorSet
-  Formula::projectors(void) {
-
-    // Empty formla, empty projector set
-    if (ax == NULL)
-      return ProjectorSet(0);
-
-    // Get free variables from formula
-    std::set<int> s = ax->fv();
-    int maxVar=0;
-    for (std::set<int>::const_iterator i=s.begin(); i != s.end(); ++i) {
-      maxVar = std::max(maxVar, *i);
-    }
-
-    bool bddWasRunning = true;
-    // Initialize buddy
-    if (!bdd_isrunning()) {
-      bddWasRunning = false;
-      bdd_init(1000, 1000);
-    }
-    if (bdd_varnum() < maxVar+1)
-      bdd_setvarnum(maxVar+1);
-
-    // First, transform the formula into a bdd
-    bdd f = ax->toBdd();
-
-    ProjectorSet p(s.size());
-
-    // Now extract the projectors for each variable
-    for (std::set<int>::const_iterator i=s.begin(); i != s.end(); ++i) {
-      bdd x = bdd_ithvar(*i);
-
-      // Compute bdd for psi -> x
-      bdd psi1 = bdd_exist((! bdd_exist( ((!x) & f), x)) & f, x);
-      //      bdd_reorder(BDD_REORDER_WIN3ITE);
-      SetExpr glbExpr = bddToSetExpr(psi1);
-
-      // Compute bdd for x -> psi
-      bdd psi2 = bdd_exist( x & f, x);
-      //      bdd_reorder(BDD_REORDER_WIN3ITE);
-      SetExpr lubExpr = bddToSetExpr(psi2);
-
-      Projector proj(*i, glbExpr, lubExpr);
-      p.add(proj);
-    }
-
-    if (!bddWasRunning)
-      bdd_done();
-
-    return p;
-  }
-
-}
-
-// STATISTICS: set-prop