gecoder-with-gecode 0.7.1

data/ext/gecode-1.3.1/contribs/graph/examples/g1.txt

@@ -0,0 +1 @@
+arc(0,1)arc(1,2)arc(2,0)

data/ext/gecode-1.3.1/contribs/graph/examples/g2.txt

@@ -0,0 +1 @@
+arc(0,1)arc(1,2)arc(2,0)arc(2,3)arc(2,4)arc(3,5)arc(4,5)

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

@@ -0,0 +1,51 @@
+/*
+ *  Main authors:
+ *     Gr�goire Dooms <dooms@info.ucl.ac.be>
+ *
+ *  Copyright:
+ *     Universit� catholique de Louvain, 2005
+ *
+ *  Last modified:
+ *     $Date: 2006-05-22 22:19:52 +0200 (Mon, 22 May 2006) $
+ *     $Revision: 476 $
+ *
+ *  This file is part of CP(Graph)
+ *
+ *  See the file "contribs/graph/LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#ifndef __GECODE_GRAPH_HH__
+#define __GECODE_GRAPH_HH__
+
+#if !defined(GECODE_STATIC_LIBS) && \
+    (defined(__CYGWIN__) || defined(__MINGW32__) || defined(_MSC_VER))
+
+#ifdef GECODE_BUILD_GRAPH
+#define GECODE_GRAPH_EXPORT __declspec( dllexport )
+#else
+#define GECODE_GRAPH_EXPORT __declspec( dllimport )
+#endif
+
+#else
+
+#define GECODE_GRAPH_EXPORT
+#endif
+
+#include "kernel.hh"
+#include "set.hh"
+#include "int.hh"
+
+using namespace Gecode;
+using namespace Gecode::Set;
+using namespace std;
+#include "var.icc"
+#include "view.icc"
+#include "path.hh"
+#include "binarysimple.hh"
+#include "branch/branch.icc"
+        
+
+#endif //__GECODE_GRAPH_HH

data/ext/gecode-1.3.1/contribs/graph/graphutils.h

@@ -0,0 +1,46 @@
+//
+/*
+ *  Main authors:
+ *     Gr�goire Dooms <dooms@info.ucl.ac.be>
+ *
+ *  Copyright:
+ *     Gr�goire Dooms (Universit� catholique de Louvain), 2005
+ *
+ *  Last modified:
+ *     $Date: 2005-11-29 10:57:21 +0100 (Tue, 29 Nov 2005) $
+ *     $Revision: 271 $
+ *
+ *  This file is part of CP(Graph)
+ *
+ *  See the file "contribs/graph/LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+//using namespace std;
+#include <utility> //for pair
+#include <vector>
+#include <boost/dynamic_property_map.hpp>
+#include <boost/tuple/tuple.hpp>
+
+/**
+ * Returns a word from decriptor file in. Used in loadAmalfi(...).
+ */
+unsigned readWord(istream& in);
+/**
+ * 
+ * Local function to load an amalfi untyped graph format file.
+ * - f is the file name
+ * - returns a pair of vectors <L1,L2> :
+ *   - L1 is the vector of n node ids ranging from [0,...,n-1]
+ *   - L2 is the vector of edges reprented by pair of node ids 
+ *
+ */
+pair<vector<int>,vector<pair<int,int> > > loadAmalfi(string f);
+
+vector<int> loadList(string filename);
+pair<vector<int>,vector<pair<int,int> > > loadGraph(const string filename);
+pair<vector<int>,vector<boost::tuple<int,int,int> > > loadGraphWeights(const string filename);
+pair<vector<int>,vector<pair<int,int> > > loadDotGraph(const string filename);
+boost::tuple<vector<int>,vector<pair<int,int> >,vector<int>,vector<pair<int,int> > > loadDotGraphOptForb(const string filename);

data/ext/gecode-1.3.1/contribs/graph/graphutils.icc

@@ -0,0 +1,140 @@
+
+/*
+ *  Main authors:
+ *     Gr�goire Dooms <dooms@info.ucl.ac.be>
+ *
+ *  Copyright:
+ *     Gr�goire Dooms (Universit� catholique de Louvain), 2005
+ *
+ *  Last modified:
+ *     $Date: 2005-11-29 10:57:21 +0100 (Tue, 29 Nov 2005) $
+ *     $Revision: 271 $
+ *
+ *  This file is part of CP(Graph)
+ *
+ *  See the file "contribs/graph/LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#include "graph.hh"
+#include <string>
+#include <vector>
+#include <utility>
+#include <list>
+#include <map>
+#include <boost/tuple/tuple.hpp>
+#include <cstdlib>
+#include <fstream>
+//using namespace std;
+//using namespace boost;
+
+namespace Gecode { namespace Graph {
+
+unsigned readWord(std::istream& in)
+  { 
+    unsigned char c1, c2;
+    c1=(char)in.get(); // Yes, I know this way I discard EOF...
+    c2=(char)in.get();
+    return c1 | (c2 << 8);
+  }
+
+std::pair<std::vector<int>,std::vector<std::pair<int,int> > > loadAmalfi(std::string f)
+{
+  std::vector<int> nodeids;
+  std::vector<std::pair<int,int> >  edges; 
+  std::ifstream in(f.c_str(), std::ios::in | std::ios::binary);
+  if (!in) {std::cerr << "loadAmalfi : File " << f <<  " not found." << std::endl; return std::make_pair(nodeids,edges);};
+  unsigned ne, dest;
+  unsigned i,j;
+
+  unsigned n = readWord(in); //Nbr of nodes in the graph
+
+
+  for (i=0; i<n; i++)
+  { 
+     nodeids.push_back((int) i);
+     ne = readWord(in);//nbr of neighbours of i
+     for(j=0; j<ne; j++)//j= nth neighbour of i
+     { 
+	dest=readWord(in);//dest=neighbour of i
+	edges.push_back(std::make_pair((int)i,(int)dest));
+     }
+  }
+
+  
+  return std::make_pair(nodeids,edges);
+}
+
+/** Loads a arc(a,b)arc(c,d) Graph.
+ * Returns a vector of numNodes elements giving the file node ids in order in first 
+ * and a sequence of arcs in second. The node ids are from 0 to numnodes-1 the original 
+ * ids can be found in first.
+ */
+std::pair<std::vector<int>,std::vector<std::pair<int,int> > >
+loadGraph(const std::string filename){
+        FILE * f = fopen(filename.c_str(),"r");
+        std::vector<std::pair<int,int> > arcs;
+        std::pair<int,int> p;
+        if (!f){
+                std::vector<int> p(0);
+                return std::make_pair(p,arcs);
+        }
+        std::list<int> l; // list of node ids
+
+        while (fscanf(f,"arc(%d,%d)",&p.first,&p.second) == 2) {
+                l.push_back(p.first);
+                l.push_back(p.second);
+                arcs.push_back(p);
+        }
+
+        l.sort();
+        l.unique();
+        std::map<int,int> idsmap; // maps the node id in the file to a number in [0,numnodes[
+        std::vector<int> ids(l.begin(),l.end()); // maps the other way around
+        int numNodes=0;
+        for (std::list<int>::iterator ii=l.begin(); ii!=l.end(); ++ii){
+                idsmap[*ii] = numNodes++;
+        }
+        for (std::vector<std::pair<int,int> >::iterator ii=arcs.begin(); ii!=arcs.end(); ++ii){
+                ii->first = idsmap[ii->first];
+                ii->second = idsmap[ii->second];
+        }
+        return std::make_pair(ids,arcs);
+}
+
+std::pair<std::vector<int>,std::vector<boost::tuple<int,int,int> > >
+loadGraphWeights(const std::string filename){
+        FILE * f = fopen(filename.c_str(),"r");
+        std::vector<boost::tuple<int,int,int> > arcsW;
+        if (!f){
+                std::vector<int> p(0);
+                return std::make_pair(p,arcsW);
+        }
+        std::list<int> l; // list of node ids
+
+        int t,h,c;
+        while (fscanf(f,"arc(%d,%d,%d)",&t,&h,&c) == 3) {
+                arcsW.push_back(boost::make_tuple(t,h,c));
+                l.push_back(t);
+                l.push_back(h);
+        }
+
+        l.sort();
+        l.unique();
+        std::map<int,int> idsmap; // maps the node id in the file to a number in [0,numnodes[
+        std::vector<int> ids(l.begin(),l.end()); // maps the other way around
+        int numNodes=0;
+        for (std::list<int>::iterator ii=l.begin(); ii!=l.end(); ++ii){
+                idsmap[*ii] = numNodes++;
+        }
+
+        for (std::vector<boost::tuple<int,int,int> >::iterator ii=arcsW.begin(); ii!=arcsW.end(); ++ii){
+               boost::tie(t,h,c) = *ii;
+                *ii  = boost::make_tuple(idsmap[t], idsmap[h], c);
+        }
+        return std::make_pair(ids,arcsW);
+}
+
+} } 

data/ext/gecode-1.3.1/contribs/graph/misc/doxygen/footer.html

@@ -0,0 +1 @@
+</html>

data/ext/gecode-1.3.1/contribs/graph/path.hh

@@ -0,0 +1,116 @@
+
+/*
+ *  Main authors:
+ *     Gr�goire Dooms <dooms@info.ucl.ac.be>
+ *
+ *  Copyright:
+ *     Gr�goire Dooms (Universit� catholique de Louvain), 2005
+ *
+ *  Last modified:
+ *     $Date: 2005-11-29 10:57:21 +0100 (Tue, 29 Nov 2005) $
+ *     $Revision: 271 $
+ *
+ *  This file is part of CP(Graph)
+ *
+ *  See the file "contribs/graph/LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#ifndef PATH_HH
+#define PATH_HH
+
+#include "kernel.hh"
+#include "int.hh"
+#include <map>
+#include <boost/utility.hpp>
+//using namespace Gecode;
+//using namespace std;
+//using namespace boost;
+
+namespace Gecode { namespace Graph {
+/** \brief Propagator for the simple path constraint
+ * 
+ * \relates PathBoundsGraphs
+ */
+template <class GView>
+class PathPropag : public  Propagator {
+        protected:
+                GView g;
+                int start, end;
+        public :
+                PathPropag(Space* home, bool share, PathPropag& p);
+        /// Destructor for cancelling 
+                ~PathPropag(void);
+        /// Constructor for posting 
+                PathPropag(Space* home, GView g, int st, int en);
+        /// perform the copy upon space cloning 
+                virtual Actor*      copy(Space*,bool);
+        // return the cost of propagation
+                virtual PropCost    cost(void) const;
+        /// perform the filtering 
+                virtual ExecStatus  propagate(Space*);
+        /// Post propagator g is a simple path from node \a start to node \a end
+                static ExecStatus post(Space* home, GView &g,int start, int end);
+};
+/** \brief Propagator for the cost-based filtering for a simple-path
+ * 
+ * \relates PathBoundsGraphs
+ */
+template <class GView>
+class PathCostPropag : public  Propagator {
+        protected:
+                GView g;///< the graph view on which the propagator is posted
+                int start, end; 
+                /** todo keep a pointer to the map instead of the map
+                 * allocated by  PathCostPropag, and kept through reference counting.
+                 * copy increments, destructor decrements and frees if count==0 
+                 * --> Use a smart pointer  */
+                map <pair<int,int>,int> ecosts; 
+                Int::IntView w; ///< the IntView for the total cost of the graph
+        public :
+                /// Copy constructor for cloning the propagator
+                PathCostPropag(Space* home, bool share, PathCostPropag& p);
+                /// Destructor 
+                ~PathCostPropag(void);
+                /// constructor for posting the propagator
+                PathCostPropag(Space* home, GView g, int st, int en, const map <pair<int,int>,int> &edgecosts, Int::IntView w);
+                /// copy the propagator to new Space
+                virtual Actor*      copy(Space*,bool);
+                /// cost of propagation
+                virtual PropCost    cost(void) const;
+                /// perform propagation
+                virtual ExecStatus  propagate(Space*);
+                /// Posts the propagator g is a path from st to en and according to the edgecosts its total cost is w
+                static ExecStatus post(Space* home, GView &g,int start, int end, Int::IntView w, const map <pair<int,int>,int> &edgecosts ) ;
+};
+
+/** \brief Propagator for a node degree=1 constraint 
+ *
+ * each node of the graph has a in/out degree of 1 iff it is part of the graph
+ * except for start and end which have resp. only outdegree and indegree equal to 1.
+ */
+template <class GView>
+class PathDegreePropag : public  Propagator {
+        protected:
+                GView g;
+                int start, end;
+        public :
+                PathDegreePropag(Space* home, bool share, PathDegreePropag& p);
+                ~PathDegreePropag(void);
+                PathDegreePropag(Space* home, GView &g, int st, int end);
+                virtual Actor*      copy(Space*,bool);
+                virtual PropCost    cost(void) const;
+                virtual ExecStatus  propagate(Space*);
+                static ExecStatus post(Space* home, GView &g,int start, int end) ;
+};
+template <class GView>
+void path(Space* home, GView &g, int start, int end, const map <pair<int,int>,int> &edgecosts , IntVar w);
+
+template <class GView>
+void path(Space* home, GView &g, int start, int end);
+
+} }
+#include "path.icc"
+#endif

data/ext/gecode-1.3.1/contribs/graph/path.icc

@@ -0,0 +1,64 @@
+
+/*
+ *  Main authors:
+ *     Gr�goire Dooms <dooms@info.ucl.ac.be>
+ *
+ *  Copyright:
+ *     Gr�goire Dooms (Universit� catholique de Louvain), 2005
+ *
+ *  Last modified:
+ *     $Date: 2005-11-29 10:57:21 +0100 (Tue, 29 Nov 2005) $
+ *     $Revision: 271 $
+ *
+ *  This file is part of CP(Graph)
+ *
+ *  See the file "contribs/graph/LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#include "path/pathdegree.icc"
+namespace Gecode { namespace Graph {
+
+/** \brief Posts a degree constraint on the graph view g.
+ *
+ * All nodes of g have indegree of 1 (except start) and out degree of 1 (except end)
+ * \ingroup TaskModel
+ */
+template <class GView>
+    void pathdegree(Space *home, GView &g, int start, int end){
+        GECODE_ES_FAIL(home, PathDegreePropag<GView>::post(home, g, start, end));
+}
+
+
+
+/** \brief posts a simple path constraint on the graph view g. 
+ *
+ * The propagator uses cost filtering based on the upper bound of w and updates the lower bound of w.
+ * \ingroup TaskModel
+ */
+template <class GView>
+void path(Space* home, GView &g, int start, int end, const map <pair<int,int>,int> &edgecosts, IntVar w) {
+        if (home->failed()) return;
+        GECODE_ME_FAIL(home, g._nodeIn(home, start));
+        GECODE_ME_FAIL(home, g._nodeIn(home, end));
+        pathdegree(home,g,start,end);
+        GECODE_ES_FAIL(home, PathCostPropag<GView>::post(home, g, start, end, w, edgecosts));
+}
+/** \brief posts a path constraint on the graph view g.
+ * \ingroup TaskModel
+ */
+template <class GView>
+void path(Space* home, GView &g, int start, int end) {
+        if (home->failed()) return;
+        GECODE_ME_FAIL(home, g._nodeIn(home, start));
+        GECODE_ME_FAIL(home, g._nodeIn(home, end));
+	    pathdegree(home,g,start,end);
+        GECODE_ES_FAIL(home, PathPropag<GView>::post(home, g, start, end));
+}
+
+} }
+#include "path/path.icc"
+
+

data/ext/gecode-1.3.1/contribs/graph/path/path.icc

@@ -0,0 +1,139 @@
+
+/*
+ *  Main authors:
+ *     Gr�goire Dooms <dooms@info.ucl.ac.be>
+ *
+ *  Copyright:
+ *     Gr�goire Dooms (Universit� catholique de Louvain), 2005
+ *
+ *  Last modified:
+ *     $Date: 2005-11-29 10:57:21 +0100 (Tue, 29 Nov 2005) $
+ *     $Revision: 271 $
+ *
+ *  This file is part of CP(Graph)
+ *
+ *  See the file "contribs/graph/LICENSE" for information on usage and
+ *  redistribution of this file, and for a
+ *     DISCLAIMER OF ALL WARRANTIES.
+ *
+ */
+
+#include "path/pathgraphs.icc"
+#include <boost/graph/iteration_macros.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <list>
+#include <map>
+#include <vector>
+#include <utility>
+
+//using namespace boost;
+//using namespace std;
+namespace Gecode { namespace Graph {
+/** Path with cost propagator */
+
+template <class GView>
+forceinline
+PathCostPropag<GView>::PathCostPropag(Space* home, GView g, int st, int en, const map <pair<int,int>,int> &edgecosts, Int::IntView w)
+        :  Propagator(home), g(g), start(st), end (en), ecosts(edgecosts), w(w){
+                g.subscribe(home,this, Gecode::Graph::PC_GRAPH_ANY);
+                w.subscribe(home,this, Gecode::Int::PC_INT_DOM);
+        }
+
+template <class GView>
+        forceinline
+        PathCostPropag<GView>::PathCostPropag(Space* home, bool share, PathCostPropag& p)
+: Propagator(home,share,p), start(p.start), end(p.end), ecosts(p.ecosts) { 
+        g.update(home,share,p.g);
+        w.update(home,share,p.w);
+}
+
+template <class GView>
+PathCostPropag<GView>::~PathCostPropag(void){ 
+        g.cancel(this, Gecode::Graph::PC_GRAPH_ANY);
+        w.cancel(this, Gecode::Int::PC_INT_DOM);
+}
+
+template <class GView>
+Actor* PathCostPropag<GView>::copy(Space* home, bool share) {
+        return new (home) PathCostPropag(home,share,*this);
+}
+
+
+template <class GView>
+ExecStatus PathCostPropag<GView>::post(Space* home, GView &g,int start, int end, Int::IntView w, const map <pair<int,int>,int> &edgecosts) {
+        (void) new (home) PathCostPropag(home,g, start, end, edgecosts, w);
+        return ES_OK;
+}
+
+template <class GView>
+PropCost PathCostPropag<GView>::cost(void) const {
+        return Gecode::PC_QUADRATIC_HI;
+}
+
+template <class GView>
+ExecStatus PathCostPropag<GView>::propagate(Space* home) {
+        TRACE(cout << "coucou propag"<<endl);
+        PathBoundsGraphs<GView> bg(g); 
+        ExecStatus e= bg.SCC_filtering(home, start, end  );
+        GECODE_ES_CHECK(e);
+        bg.resetVertexIndexUB();
+        bg.resetEdgeIndexUB();
+        TRACE(cout << "cost filtering:" << endl);
+        ExecStatus e2;
+        int wL,wU;
+        boost::tie(e2,wL,wU) = bg.cost_filtering(home, start, end, ecosts, w.max());
+        //TODO define a good way (tm) of combining ExecStatus
+        GECODE_ES_CHECK(e2);
+        e = std::min(e,e2);
+        TRACE(cout << "reducing the weight according to computed bounds:" << endl);
+        GECODE_ME_CHECK(w.gq(home,wL));
+        GECODE_ME_CHECK(w.lq(home,wU));
+        TRACE(cout << "au revoir propag" << endl);
+        return e;
+}
+/** Simple path propagator */
+
+template <class GView>
+forceinline
+PathPropag<GView>::PathPropag(Space* home, GView g, int st, int en)
+        :  Propagator(home), g(g), start(st), end (en){
+                g.subscribe(home,this, Gecode::Graph::PC_GRAPH_ANY);
+        }
+
+template <class GView>
+        forceinline
+        PathPropag<GView>::PathPropag(Space* home, bool share, PathPropag& p)
+: Propagator(home,share,p), start(p.start), end(p.end){ 
+        g.update(home,share,p.g);
+}
+
+template <class GView>
+PathPropag<GView>::~PathPropag(void){ 
+        g.cancel(this, Gecode::Graph::PC_GRAPH_ANY);
+}
+
+template <class GView>
+Actor* PathPropag<GView>::copy(Space* home, bool share) {
+        return new (home) PathPropag(home,share,*this);
+}
+
+
+template <class GView>
+ExecStatus PathPropag<GView>::post(Space* home, GView &g,int start, int end) {
+        (void) new (home) PathPropag(home,g, start, end);
+        return ES_OK;
+}
+
+template <class GView>
+PropCost PathPropag<GView>::cost(void) const {
+        return Gecode::PC_QUADRATIC_HI;
+}
+
+template <class GView>
+ExecStatus PathPropag<GView>::propagate(Space* home) {
+        TRACE(cout << "coucou propag"<<endl);
+        PathBoundsGraphs<GView> bg(g); 
+        ExecStatus e = bg.SCC_filtering(home,start,end  );
+        return e;
+}
+} }