gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/contribs/map/examples/subgraphmonomorphism.cc

@@ -0,0 +1,155 @@
+/*
+ *  Main authors:
+ *     Zampelli St�phane <sz@info.ucl.ac.be> 
+ *
+ *  Copyright:
+ *     Universit� catholique de Louvain, 2005
+ *
+ *  Last modified:
+ *     $Date$
+ *     $Revision$
+ *
+ *  This file is part of CP(Map)
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+
+#include <iostream>
+#include <iomanip>
+#include <cstdlib>
+#include <cstring>
+
+#include "kernel.hh"
+#include "search.hh"
+
+#include "examples/timer.hh"
+#include "examples/support.hh"
+#include "minimodel.hh"
+#include "map.hh"
+#include "matching/mono.hh"
+#include "int.hh"
+#include "set.hh"
+#include "graph.hh"
+#include "graphutils.icc"
+
+using namespace Gecode::Map;
+using namespace Gecode;
+
+template<class GView>
+SetVar extractNodes(Space *home, GView g)
+{
+	SetVar s;
+	nodes(home, g, s);
+	return s;
+}
+
+/**
+ * 
+ * \brief Subgraph monomorphism problem
+ * \ingroup MatchingExamples
+ * 
+ *  Treats the subgraph monomorphism problem between two ground graphs
+ *  and finds the corresponding function.
+ */
+//@{
+class SubgraphMonomorphism : public Example {
+   private:
+      OutAdjSetsGraphView P;
+      OutAdjSetsGraphView T;
+      OutAdjSetsGraphView t;
+      MapVar M;
+
+   public:
+      SubgraphMonomorphism(const Options& opt, const string pattern, const string target) 
+	 : P(this,loadAmalfi(pattern)), T(this, loadAmalfi(target)), t(this, loadAmalfi(target)), 
+	 M(this, P.nodes, T.nodes)// extractNodes(this,P), extractNodes(this, T)) 
+	 {
+	    TRACE_MAP(cout << "Pattern graph : " << endl);
+	    TRACE_MAP(cout << P << endl);
+	    TRACE_MAP(cout << "Target graph : " << endl);
+	    TRACE_MAP(cout << T << endl);
+	    P.instantiateUB(this);
+	    inducedSubgraph(this, T, t);
+
+	    //monomorphism constraint performing propagation
+	    monoInduced(this, P, T, M);
+	    branch(this, M, BVAR_SIZE_MIN, BVAL_MIN);  
+	 }
+
+      /// Constructor for cloning \a s
+      SubgraphMonomorphism(bool share, SubgraphMonomorphism& s) : Example(share,s)
+      {
+	 TRACE_MAP(cout << "update" << endl);
+	 P.update(this,share,s.P);
+	 T.update(this,share,s.T);
+	 t.update(this,share,s.t);
+	 M.update(this,share,s.M); 
+	 TRACE_MAP(M.print());
+	 TRACE_MAP(cout << "endupdate" << endl);
+      } 
+
+      /// Perform copying during cloning
+      virtual Space*
+	 copy(bool share) {
+	    TRACE_MAP(cout << "copying" << endl);
+	    return new SubgraphMonomorphism(share,*this);
+	 }
+
+      /// Print solution
+      virtual void print(void) {
+	 cout << "\n----------\n----------\nSOLUTION :\n----------\n----------" << endl;
+	 for (int i=0; i<(int) M.maxInitDomSize(); i++)
+	 {
+	    cout <<"(" << i << ", " << M.imageAssigned(i) << ")";
+	 }
+	 cout << endl;
+      }
+};
+//@}
+
+   int main(int argc, char** argv) {
+      if (argc<3)
+	 cout << argv[0] << " <Pattern file> <Target file>" << endl;
+      Options o("SubgraphMonomorphism");
+      o.solutions = 0;
+      o.iterations = 200;
+      o.size       = 100;
+      o.c_d        = 5;
+      //o.parse(argc,argv);
+      Timer t;
+      int i = o.solutions;
+      t.start();
+      string s1(argv[1]);
+      string s2(argv[2]);
+      SubgraphMonomorphism* s = new SubgraphMonomorphism(o, s1, s2);
+      DFS<SubgraphMonomorphism> e(s,o.c_d,o.a_d);
+	delete s;
+	do {
+	  Example* ex = e.next();
+	  if (ex == NULL)
+	    break;
+	  ex->print();
+	  delete ex;
+	} while (--i != 0);
+	Search::Statistics stat = e.statistics();
+	cout << endl;
+	cout << "Summary" << endl
+	     << "\truntime:      " << t.stop() << endl
+	     << "\tsolutions:    " << abs(static_cast<int>(o.solutions) - i) << endl
+	     << "\tpropagations: " << stat.propagate << endl
+	     << "\tfailures:     " << stat.fail << endl
+	     << "\tclones:       " << stat.clone << endl
+	     << "\tcommits:      " << stat.commit << endl
+	     << "\tpeak memory:  " 
+	     << static_cast<int>((stat.memory+1023) / 1024) << " KB"
+	     << endl;
+
+      return 0;
+   }
+
+// STATISTICS: example-any
+

data/ext/gecode-1.3.1/contribs/map/map.hh

@@ -0,0 +1,65 @@
+/*
+ *  Main authors:
+ *     Zampelli St�phane <sz@info.ucl.ac.be>
+ *
+ *  Copyright:
+ *     Universit� catholique de Louvain, 2005
+ *
+ *  Last modified:
+ *     $Date$
+ *     $Revision$
+ *
+ *  This file is part of CP(Map)
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#ifndef __GECODE_MAP_HH__
+#define __GECODE_MAP_HH__
+
+#define TRACE_MAP(A) 
+
+#if !defined(GECODE_STATIC_LIBS) && \
+    (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))
+
+#ifdef GECODE_BUILD_MAP
+#define GECODE_MAP_EXPORT __declspec( dllexport )
+#else
+#define GECODE_MAP_EXPORT __declspec( dllimport )
+#endif
+
+#else
+
+#define GECODE_MAP_EXPORT
+
+#endif
+
+#include "support/shared-array.hh"
+#include "set.hh"
+#include "int.hh"
+
+using namespace std;
+using namespace Gecode::Set;
+using namespace Gecode::Int;
+
+//The header file "int/distinct.hh" is needed 
+//for the branch function uses BvarSel vars, BvalSel vals.
+//This is temporary until branching has been integrated with  
+//the branching Gecode schema.
+#include "int/branch.hh" 
+#include "int/count.hh" 
+#include "var.icc"
+
+using namespace Gecode::Map;
+using namespace Gecode;
+
+#include "constraints.hh"
+
+using namespace Gecode::Int::Count;
+
+
+#endif //__GECODE_MAP_HH
+

data/ext/gecode-1.3.1/contribs/map/matching/mono.hh

@@ -0,0 +1,235 @@
+/*
+ *  Main authors:
+ *     Zampelli St�phane <sz@info.ucl.ac.be>
+ *
+ *  Copyright:
+ *     Universit� catholique de Louvain, 2005
+ *
+ *  Last modified:
+ *     $Date$
+ *     $Revision$
+ *
+ *  This file is part of CP(Map)
+ *
+ *  See the file "LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+
+#include "graph.hh"
+#include "set/int.hh" //used to post the cardinality constraint
+#include "set.hh"
+#include <boost/tuple/tuple.hpp>
+
+using namespace Gecode::Graph;
+using namespace boost;
+
+namespace Gecode { namespace Map {
+
+   /**
+    * \defgroup MatchingPropa Matching propagator classes
+    *
+    * This module contains propagator classes used to implement the monomorphism 
+    * and isomorphism constraints. 
+    */
+   //@{
+   /**
+    * \brief Propagator for inducing a GraphVar over another one
+    *
+    * The type \a GView can be any view on a GraphVar.
+    * 
+    * Limitations : 
+    *
+    * 1. the second GraphVar must be ground (TODO in CP(Map) 0.2)
+    *
+    */
+   template <class GView>
+      class InducedSubgraph : public Propagator {
+	 protected:
+	    ///Represent the induced graph
+	    GView gp;
+	    ///*ground* GraphVar representing the structure 
+	    GView gt;
+	    ///Constructor for cloning \a p
+	    InducedSubgraph(Space*, bool share, InducedSubgraph &p);
+
+	 public:
+	    ///Constructor for creation 
+	    InducedSubgraph(Space* home, GView g1, GView g2);
+	    ///Destructor 
+	    ~InducedSubgraph();
+
+	    /// Create copy during cloning
+	    virtual Actor*      copy(Space*,bool);
+	    /// Perform propagation
+	    virtual ExecStatus  propagate(Space*);
+	    /// Cost function 
+	    virtual PropCost    cost(void) const;
+	    /// Post propagator 
+	    static  ExecStatus  post(Space* home, GView g1, GView g2);
+      };
+
+   /**
+    * \brief Propagator for \f$ (i,j) \in Arcs(P) \rightarrow (M(i),M(j)) \in Arcs(T) \f$ 
+    *
+    * The type \a GView can be any view on a GraphVar.
+    *
+    * Limitations : 
+    *
+    * 1. class Gview must be class OutAdjSetsGraphView (FIX in CP(Map) 0.2)
+    *
+    */
+   template <class GView>
+      class ImplyArcs : public Propagator {
+	 protected:
+	    ///Represents P
+	    GView gp;
+	    ///Represents T
+	    GView gt;
+	    ///Represents the mapping
+	    MapVar M;
+	    ///Constructor for cloning \a p
+	    ImplyArcs(Space*, bool share, ImplyArcs &p);
+
+	 public:
+	    ///Constructor for creation 
+	    ImplyArcs(Space* home, GView P, GView T, MapVar M);
+	    ///Destructor
+	    ~ImplyArcs();
+
+	    /// Create copy during cloning
+	    virtual Actor*      copy(Space*,bool);
+	    /// Perform propagation
+	    virtual ExecStatus  propagate(Space*);
+	    /// Cost function 
+	    virtual PropCost    cost(void) const;
+	    /// Post propagator 
+	    static  ExecStatus  post(Space* home, GView P, GView T, MapVar M);
+
+      };
+
+   /**
+    * \brief Propagator for \f$ (i,j) \in Arcs(P) \rightarrow (M(i),M(j)) \in Arcs(T) \f$ 
+    *        where P and T are induced 
+    *
+    * The type \a GView can be any view on a GraphVar.
+    *
+    * Limitations : 
+    *
+    * 1. Only checking is performed 
+    *
+    */
+
+   template <class GView>
+      class MonoInduced : public Propagator {
+	 private:
+	    pair<vector<int>,vector<pair<int,int> > > extractUB(GView g1); 
+	    void initS(Space *home);
+	    void initlast(Space *home);
+	    void difflast(map<int,vector<int> > &p);
+	    void printS(void);
+	    void printdifflast(map<int, vector<int> >& diff);
+	    void printlast();
+	    int computeSOut(int a, int b);
+	    int computeSIn(int a, int b);
+	    void putS(int a, int b, int v, map<int,int> &S);
+	    int getS(int a, int b, map<int,int> &S);
+	    void decS(int a, int b, map<int,int> &S);
+	    ModEvent _propNeighOut(Space *home, int i, int a);
+	    ModEvent _propNeighIn(Space *home, int i, int a);
+	    ModEvent _propNeighOutB(Space *home, int i, int a);
+	    ModEvent _propNeighInB(Space *home, int i, int a);
+
+	    vector<int> computeLeftInit(Space* home, GView g);
+	 protected:
+	    ///Represents P
+	    GView gp;
+	    ///Represents T
+	    GView gt;
+	    ///Represents the mapping
+	    MapVar M;
+	    ///Represents the ground structure of P
+	    GView gp_ground;
+	    ///Represents the ground structure of T
+	    GView gt_ground;
+	    ///Represents the domain of M at the end of the preivous propagation step.
+	    vector<pair<int, list<int> > > last;
+	    ///\f$ Sin(i,a) = |D(x_i) \cap Vin(a)| \f$
+	    map<int, int> Sin; 
+	    ///\f$ DSout(i,a) = |D(x_i) \cap Vout(a)| \f$
+	    map<int, int> Sout; 
+	    ///Has xiInitialization propagation already been done ?
+	    bool initdone;
+	    //list of nodes not in LB(nodes(P)) -- used to trigger conditional propagation 
+	    vector<int> left; 
+	    ///Constructor for cloning \a p
+	    MonoInduced(Space*, bool share, MonoInduced &p);
+
+	 public:
+	    ///Constructor for creation 
+	    MonoInduced(Space* home, GView P, GView T, MapVar M);
+	    ~MonoInduced();
+
+	    /// Create copy during cloning
+	    virtual Actor*      copy(Space*,bool);
+	    /// Perform propagation
+	    virtual ExecStatus  propagate(Space*);
+	    /// Cost function 
+	    virtual PropCost    cost(void) const;
+	    /// Post propagator 
+	    static  ExecStatus  post(Space* home, GView P, GView T, MapVar M);
+      };
+
+
+   //@}
+
+}
+}
+
+namespace Gecode {
+/**
+ * \defgroup MathcingFunctions Matching modelisation functions
+ * 
+ */
+   //@{
+   
+   ///Provided Nodes(P)=Nodes(T) and T is ground, P is a graph induced on T.  
+   template <class GView>
+   void inducedSubgraph(Space *, GView P, GView T);
+
+   ///\f$\forall \; (x,y) \; \in Args(P) : (M(x),M(y)) \in Arcs(T)\f$
+   template <class GView>
+   void implyArcs(Space *, GView P, GView T, MapVar M);
+
+   ///P and T are monomorphic w.r.t injective mapping M
+   ///only checking is performed
+   template <class GView>
+   void mono(Space *, GView P, GView T, MapVar M);
+
+   ///P and T are isomorphic w.r.t. bijective mapping M
+   template <class GView>
+   void iso(Space *, GView P, GView T, MapVar M);
+
+   ///P and T are isomorphic w.r.t. bijective mapping M
+    ///Propagation is performed
+   ///Precondition : P and T must be induced. 
+   template <class GView>
+   void isoInduced(Space *, GView P, GView T, MapVar M);
+   
+   ///P and T are monomorphic w.r.t. injective mapping M
+   ///Propagation is performed
+   ///Precondition : P and T must be induced. 
+   template <class GView>
+   void monoInduced(Space *, GView P, GView T, MapVar M);
+
+   template <class GView>
+   void nodes(Space *home, GView g1, SetVar s);
+
+   //@}
+   
+}
+
+
+#include "matching/mono.icc"