gecoder-with-gecode 0.7.1 → 0.8.0

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

@@ -1,133 +0,0 @@
-
-/*
- *  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 <list>
-//using namespace boost;
-//using namespace std;
-namespace Gecode { namespace Graph {
-template <class GView> 
-    void pathdegree(Space *home, GView &g, int start, int end);
-template <>
-    void pathdegree(Space *home, OutAdjSetsGraphView &g, int start, int end){
-        int numNodes = g.outN.size();
-        BoolVarArray b(home,3*numNodes,0,1);
-        #define iInNodes(i)  b[0+3*(i)]
-        #define iNotInNodes(i) b[1+3*(i)]
-        #define iOutsEmpty(i) b[2+3*(i)]
-        Gecode::IntSet empty;
-
-        for (int i=0 ; i<numNodes ; i++){
-                //include(home,nodes,i,iInNodes(i));
-                dom(home, g.nodes, SRT_SUP, i, iInNodes(i));
-                bool_not(home, iInNodes(i), iNotInNodes(i));
-                dom(home, g.outN[i], SRT_EQ, empty, iOutsEmpty(i)); 
-        }
-        cardinality(home,g.outN[end],0,0); 
-
-        //outdegree(i) == i in nodes
-        for (int i=0; i<numNodes; i++){
-                if (i!=end)
-                        cardinality(home,g.outN[i],iInNodes(i));
-        }
-        //indegree(i) == i in nodes
-        //        selectDisjoint(home,outN,outN[numNodes]);
-        //replaced with: 
-        for (int i=0; i< numNodes; i++){
-                IntVarArgs iinOuts(numNodes);
-                for (int j=0 ; j< numNodes; j++){
-                        BoolVar b(home,0,1);
-                        iinOuts[j]=b;
-                        dom(home,g.outN[j],SRT_SUP,i,b);
-                }
-                if (i !=start)
-                        linear(home,iinOuts,IRT_EQ,iInNodes(i));
-                else
-                        linear(home,iinOuts,IRT_EQ,0);
-        }
-}
-
-template <class GView>
-PathDegreePropag<GView>::~PathDegreePropag(void){ 
-        g.cancel(this, Gecode::Graph::PC_GRAPH_ANY);
-}
-
-template <class GView>
-Actor* PathDegreePropag<GView>::copy(Space* home, bool share) {
-        return new (home) PathDegreePropag(home,share,*this);
-}
-
-template <class GView>
-PathDegreePropag<GView>::PathDegreePropag(Space* home, GView &g,int start, int end): Propagator(home), g(g), start(start), end(end) {
-	g.subscribe(home,this, Gecode::Graph::PC_GRAPH_LUB);
-}
-
-template <class GView>
-ExecStatus PathDegreePropag<GView>::post(Space* home, GView &g,int start, int end) {
-        (void) new (home) PathDegreePropag(home,g, start, end);
-        return ES_OK;
-}
-
-template <class GView>
-PropCost PathDegreePropag<GView>::cost(void) const {
-        return Gecode::PC_QUADRATIC_LO;
-}
-
-template <class GView>
-        forceinline
-        PathDegreePropag<GView>::PathDegreePropag(Space* home, bool share, PathDegreePropag& p)
-: Propagator(home,share,p) { 
-        g.update(home,share,p.g);
-}
-
-template <class GView>
-ExecStatus PathDegreePropag<GView>::propagate(Space* home) {
-// Pruning rules:
-// if an arc is in LB remove other arcs (in UB) with same head or same tail
-// Not implemented : if a node is in LB and there is only one arc with it as head or as tail then that arc gets in LB.
-
-	map<int,int> tail; //head -> tail of arcs in LB
-	map<int,int> head; //tail -> head
-
-	typename GView::GlbArcIterator  l = g.iter_arcs_LB();
-	for (; l(); ++l){
-		int t,h;
-        boost::tie(t,h) = l.val();
-		head[t] = h;
-		tail[h] = t;
-	}
-
-	list<pair<int,int> > removeArcs;
-	typename GView::LubArcIterator  u = g.iter_arcs_UB();
-	for (; u(); ++u){
-		int t,h;
-		boost::tie(t,h) = u.val();
-        map<int,int>::iterator i;
-		if (((i = head.find(t)) != head.end() && i->second != h) ||
-            ((i = tail.find(h)) != tail.end() && i->second != t)) {
-		    removeArcs.push_back(make_pair(t,h));
-        }
-	}
-	// XXX TODO replace with an adequate removeArcs method
-	for (list<pair<int,int> >::const_iterator k=removeArcs.begin(); k!=removeArcs.end(); ++k){
-		GECODE_ME_CHECK(g._arcOut(home,k->first,k->second));
-	}
-    return ES_FIX;
-}
-} } 

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

@@ -1,341 +0,0 @@
-
-/*
- *  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 <list>
-#include <vector>
-#include <utility>
-#include <boost/utility.hpp>
-#include <boost/graph/strong_components.hpp>
-#include <boost/graph/graphviz.hpp>
-#include <boost/graph/graph_utility.hpp>
-#include <boost/graph/topological_sort.hpp>
-#include <boost/graph/depth_first_search.hpp>
-#include <boost/graph/visitors.hpp>
-#include <boost/property_map.hpp>
-#include <boost/graph/reverse_graph.hpp>
-#include <boost/graph/dijkstra_shortest_paths.hpp>
-#include <boost/graph/iteration_macros.hpp>
-#include <boost/tuple/tuple.hpp>
-//using namespace boost;
-//using namespace std;
-
-namespace Gecode { namespace Graph {
-
-/** \brief  BoundsGraphs datastructure for the path propagator 
- *
- * \relates PathPropag PathCostPropag*/
-template <class GDV>
-class PathBoundsGraphs : public BoundsGraphs<GDV> {
-//TODO : Still missing the lower bound propagation
-        using BoundsGraphs<GDV>::UB;
-        using BoundsGraphs<GDV>::LB;
-        using BoundsGraphs<GDV>::UB_v;
-        using BoundsGraphs<GDV>::LB_v;
-        using BoundsGraphs<GDV>::numNodes;
-        using BoundsGraphs<GDV>::arcOut;
-        using BoundsGraphs<GDV>::nodeOut;
-      public:
-        using BoundsGraphs<GDV>::resetVertexIndexUB;
-        using BoundsGraphs<GDV>::resetEdgeIndexUB;
-        PathBoundsGraphs(GDV &g);
-        ExecStatus SCC_filtering(Space* home, int start, int end);
-        boost::tuple<ExecStatus,int,int> cost_filtering(Space* home, int sourceID, int targetID, const map <pair<int,int>,int> &edgecosts ,int uppercost);
-};
-
-        /// Builds a PathBoundsGraphs from the current domain of a Graph View of type GDV
-        template <class GDV>
-        PathBoundsGraphs<GDV>::PathBoundsGraphs(GDV &g): BoundsGraphs<GDV>(g){}
-
-/** \brief  Topological propagation for the path constraint
- * 
- *  Enforces the graph to be a simply connected component: 
- *  all nodes must be reachable from the source
- *
- *  Checks the nodes in LB are all in same CC of UB.
- *  Removes the other components of UB.
- *
- *  Checks the nodes in UB are part of a single SCC if a back edge is added 
- *  --> intersection of nodes reachable from source and nodes that can be reached from end
- *  
- *  Check no two LB nodes are in parallel branches of the condensed graph (== DAG)
- */
-template <class GDV>
-ExecStatus PathBoundsGraphs<GDV>::SCC_filtering(Space* home, int sourceID, int targetID){
-        
-
-        // std::map<Gecode::Graph::Graph::vertex_descriptor, default_color_type> color;
-        Gecode::Graph::Graph::vertex_descriptor s = UB_v[sourceID];
-        boost::dfs_visitor<boost::null_visitor> t;
-        // YYY replace this map with a vector and use iterator_property_map with Node::index
-        typedef std::map<Gecode::Graph::Graph::vertex_descriptor,boost::default_color_type> CMT;
-        CMT v2c;
-        boost::associative_property_map<CMT> cmap(v2c);
-        Gecode::Graph::Graph::vertex_iterator vi,vi_end, next;
-        boost::tie(vi,vi_end) = vertices(UB);
-        for (;vi!=vi_end; ++vi){
-                cmap[*vi]=boost::white_color;
-        }
-        boost::depth_first_visit(UB,s,t, cmap);
-        boost::tie(vi,vi_end) = vertices(UB);
-        TRACE(cout << "depth_first_done "<< num_vertices(UB) << " nodes in UB" << endl);
-        int cnodes = 0;
-        for (next = vi; vi != vi_end; vi = next) {
-                ++next;
-                ++cnodes;
-                TRACE(cout << get(cmap,*vi) );
-                if (get(cmap,*vi) == boost::white_color){
-                        TRACE(cout <<"UB node "<< UB[*vi].id << " is still white"<<endl);
-                        if (LB_v[UB[*vi].id]){
-                                TRACE(cout << "It is also in LB"<<endl);
-                        }
-                        GECODE_ME_CHECK(nodeOut(home,UB[*vi].id));
-
-                }
-        }
-        TRACE(cout << cnodes << "nodes processed, single_cc done proceeding with cambazard"<<endl);
-        // cambazard :  
-        // Step 1 add a back edge and prune everything out the SCC then remove back edge.
-        // Step 2 Compute condensed graph CG. CG is a DAG. On CG, if a node is parallel to a 
-        // kernel node remove it.
-
-        // Step 1 
-        Gecode::Graph::Graph::edge_descriptor e_tmp;
-        bool b;
-        boost::tie(e_tmp,b) = add_edge(UB_v[targetID], UB_v[sourceID], UB);
-
-        // YYY replace this map with a vector and use iterator_property_map with Node::index
-        typedef std::map<Gecode::Graph::Graph::vertex_descriptor,Gecode::Graph::Graph::vertices_size_type> CN;
-        CN v2comp;
-        boost::associative_property_map<CN> compmap(v2comp);
-
-        resetVertexIndexUB();
-        boost::strong_components(UB,compmap,vertex_index_map(get(&Node::index, UB)));
-        Gecode::Graph::Graph::vertices_size_type good_comp = compmap[UB_v[sourceID]];
-        boost::tie(vi,vi_end) = vertices(UB);
-        for (next = vi; vi != vi_end; vi = next) {
-                ++next;
-                if (compmap[*vi] != good_comp){
-                        TRACE(cout << "node "<< UB[*vi].id  << " is in comp "<< compmap[*vi] << " instead of comp " << good_comp << endl);
-                        GECODE_ME_CHECK(nodeOut(home,UB[*vi].id));
-                }
-        }
-        remove_edge(e_tmp,UB); 
-        resetVertexIndexUB();
-        v2comp.clear();
-        int numcomp = boost::strong_components(UB,compmap,vertex_index_map(get(&Node::index, UB)));
-
-        TRACE(cout << "numcomp = " << numcomp << endl);
-        //Build the reduced graph using the info in compmap
-        typedef boost::adjacency_list<boost::vecS, boost::setS, boost::directedS, boost::property<boost::vertex_index_t, std::size_t>, boost::no_property> RGraph;
-        TRACE(cout << "indexes: ");
-        RGraph RG(numcomp);
-        vector<RGraph::vertex_descriptor> comp2Rv(numcomp);
-        RGraph::vertex_iterator rvi,rvi_end;
-        boost::tie(rvi,rvi_end) = vertices(RG);
-        // rnode descr-> rnode id
-        boost::property_map<RGraph, boost::vertex_index_t>::type rd2id = get(boost::vertex_index, RG);
-        int i = 0;
-        for (;rvi!=rvi_end; ++rvi, ++i){
-                comp2Rv[i]=*rvi;
-                rd2id[*rvi]=i;
-                TRACE(cout << i << " ");
-        }
-        assert(rvi==rvi_end && i==numcomp);
-        boost::tie(vi,vi_end) = vertices(UB);
-        std::vector< std::list<int> > compnodes(numcomp); // rnode_id->list of component node UB id
-        for (;vi!=vi_end; ++vi){
-                compnodes[compmap[*vi]].push_back(UB[*vi].id); 
-        }
-
-
-        TRACE(cout << endl);
-        //edges
-        Gecode::Graph::Graph::edge_iterator ei,ei_end;
-        boost::tie(ei,ei_end) = edges(UB);
-        for (;ei!=ei_end; ++ei){
-                if (compmap[source(*ei,UB)] != compmap[target(*ei,UB)]){
-                        TRACE(cout << "add_Edge "<<compmap[source(*ei,UB)]<<" "<< compmap[target(*ei,UB)] << endl);
-                        add_edge(comp2Rv[compmap[source(*ei,UB)]], 
-                                        comp2Rv[compmap[target(*ei,UB)]], RG);
-                }
-        }
-
-        //RG is built, now do a topological sort on it and remove the vertices
-        typedef std::vector< RGraph::vertex_descriptor > TO_C;
-        TO_C toporder; // vector with topol sorted rnode desc.
-        toporder.reserve(numcomp);
-        TRACE(cout << "reduced_graph top. order:" << endl);
-        //TRACE(write_graphviz(cout,RG));
-
-        boost::topological_sort(RG, std::back_inserter(toporder));
-
-        std::vector<int> UBn_order(numNodes);// for each UBid  -> index in topol
-        //compute the topological order of the nodes in UB
-        //store the indice in the UBn_order vector
-        TO_C::iterator rd_i=toporder.begin();
-        for (int j=0; rd_i!=toporder.end(); ++rd_i, ++j){
-                TRACE(cout << *rd_i << " -> ");
-                TRACE(cout << rd2id[*rd_i] << "\n");
-                for (list<int>::iterator n=compnodes[rd2id[*rd_i]].begin();
-                                n!=compnodes[rd2id[*rd_i]].end(); ++n){
-                        UBn_order[*n]=j;
-                }
-        }
-        TRACE(cout << endl);
-
-
-
-        int last_kernel_node_index=0, next_knid=0;
-        //for all nodes in rgraph starting from the sink up to the source
-        for (rd_i=toporder.begin(); rd_i!=toporder.end(); ++rd_i){ 
-                // for all real UB node associated to the rnode
-                bool chng_knid = false;
-                for (list<int>::iterator UBid_i = compnodes[rd2id[*rd_i]].begin();
-                                UBid_i!=compnodes[rd2id[*rd_i]].end(); ++UBid_i  ){
-                        // list of edges to be removed (removing an edge invalidates all edge iterators)
-                        std::list<std::pair<int,int> > remove;
-
-                        Gecode::Graph::Graph::adjacency_iterator av,av_end,next;
-                        boost::tie(av,av_end) = adjacent_vertices(UB_v[*UBid_i],UB);
-
-                        // for all out neighbor of this node in UB.
-                        for (next=av; av != av_end ; av=next){
-                                ++next;
-                                //If an edge jumps over the last encountered kern node, remove the edge.
-                                if(UBn_order[UB[*av].id] < last_kernel_node_index){
-                                        TRACE(cout<<"arc "<<*UBid_i<<" "<<UB[*av].id<<" jumps over last kern node"<<endl);
-                                        remove.push_back(make_pair(*UBid_i,UB[*av].id));
-                                }
-                        }
-                        for (list<pair<int,int> >::iterator r=remove.begin(); r!=remove.end(); ++r){
-                                TRACE(cout << "removing edge " << r->first << " "<<r->second <<endl);
-                                GECODE_ME_CHECK(arcOut(home,r->first,r->second));
-                        }
-
-                        // if the real node is a kernel node then update last_kernel_node_index.
-                        if (LB_v[*UBid_i]){
-                                TRACE(cout <<*UBid_i<< " is kernel of order "<<UBn_order[*UBid_i] << endl);
-                                chng_knid = true;
-                                next_knid = UBn_order[*UBid_i];
-                        }
-
-                }
-                if (chng_knid) {
-                        last_kernel_node_index = next_knid;
-                }
-        }
-
-        TRACE(cout << endl);
-        return ES_OK;
-}
-//#include <dijkstra_shortest_paths_old.hpp> // found a bug in boost.graph 1.33 this is 1.32 version/bugfree
-
-
-/** \brief  Removes arcs from the upper bound according to cost information 
- * This is based on what is done in M. Sellmann thesis but here with a naive non-incremental way
- * returns a tuple with execstatus and 2 new bounds for the weight.
- * PRE: the weights are non-negative
- */
-template <class GDV>
-boost::tuple<ExecStatus,int,int> PathBoundsGraphs<GDV>::cost_filtering(Space* home, int sourceID, int targetID, const map <pair<int,int>,int> &edgecosts ,int uppercost){
-
-        // perform a SSSP in forward direction from sourceID s
-        // and a SSSP in reverse direction from targetID t
-        // store the distances F(x) = D(s,x,G) and R(y) = D(t,y,G^-1)  in two maps or vectors
-        // for each edge (i,j), check that it is possible by
-        // F(i) + Cij + R(j) <= uppercost 
-
-        TRACE(cout << this << endl);
-        std::vector<int> e2w(num_edges(UB));
-        BGL_FORALL_EDGES(e, UB, Gecode::Graph::Graph) {
-                e2w[UB[e].index] =  edgecosts.find(make_pair(UB[source(e,UB)].id, UB[target(e,UB)].id ))->second ; // not using edgecosts[make_pair...] because operator[] inserts keys if missing
-        }
-
-        std::vector<int> dist(num_vertices(UB)) ;
-        Gecode::Graph::Graph::vertex_descriptor s = UB_v[sourceID];
-        // see http://www.boost.org/libs/graph/doc/bundles.html weight_map(get(&Highway::miles, map)) for distance_map and weight map
-        dijkstra_shortest_paths(UB, s, distance_map(make_iterator_property_map(&dist[0], get(&Node::index, UB))).vertex_index_map(get(&Node::index, UB)).weight_map(make_iterator_property_map(&e2w[0], get(&Edge::index, UB))));//.distance_compare(std::less<int>()));
-        std::vector<int> rdist(num_vertices(UB)) ;
-        boost::reverse_graph<Gecode::Graph::Graph> R(UB);
-        Gecode::Graph::Graph::vertex_descriptor t = UB_v[targetID];
-        boost::dijkstra_shortest_paths(R, t, boost::distance_map(boost::make_iterator_property_map(&rdist[0], get(&Node::index, UB))).vertex_index_map(get(&Node::index, UB)).weight_map(make_iterator_property_map(&e2w[0], get(&Edge::index, UB))).distance_compare(std::less<int>()));
-
-        vector<Gecode::Graph::Graph::edge_descriptor> removed; //temp for debug
-        vector<Gecode::Graph::Graph::vertex_descriptor> removednodes; //temp for debug
-        BGL_FORALL_VERTICES(v, UB, Gecode::Graph::Graph) {
-                if (dist[UB[v].index] + rdist[UB[v].index] > uppercost ) {
-                        removednodes.push_back(v);
-                }
-        }
-        BGL_FORALL_EDGES(e, UB, Gecode::Graph::Graph) {
-                if (dist[UB[source(e,UB)].index] + rdist[UB[target(e,UB)].index] + e2w[UB[e].index] > uppercost ) {
-                        removed.push_back(e);
-                }
-        }
-
-
-        TRACE(cout << "upper bound of cost : " << uppercost<<endl);
-        TRACE(cout << "######################################################" << endl);
-        TRACE(cout << "digraph { " << endl);
-        BGL_FORALL_VERTICES(v, UB, Gecode::Graph::Graph) {
-                TRACE(cout << UB[v].id << "[label='" << dist[UB[v].index] << "," << rdist[UB[v].index] << "']"<<endl );
-        }
-        BGL_FORALL_EDGES(e, UB, Gecode::Graph::Graph) {
-                TRACE(cout << UB[source(e,UB)].id << "->" << UB[target(e,UB)].id << "[label='"<<e2w[UB[e].index]<< "'");
-                if (find(removed.begin(), removed.end(), e) != removed.end()){
-                        TRACE(cout << " color=red]");
-                }
-                else {
-                        TRACE(cout << "]");
-                }
-                TRACE(cout << endl);
-        }
-        TRACE(cout << "}" << endl);
-        TRACE(cout << "######################################################" << endl);
-
-#define GECODE_ME_CHECK_3TUPLE(me) if (::Gecode::me_failed(me))\
-        return ::boost::make_tuple(::Gecode::ES_FAILED,0,0);
-
-        for (vector<Gecode::Graph::Graph::edge_descriptor>::iterator i = removed.begin(); i<removed.end(); ++i)
-                GECODE_ME_CHECK_3TUPLE(arcOut(home,UB[source(*i,UB)].id, UB[target(*i,UB)].id));
-        for (vector<Gecode::Graph::Graph::vertex_descriptor>::iterator i = removednodes.begin(); i<removednodes.end(); ++i)
-                GECODE_ME_CHECK_3TUPLE(nodeOut(home,UB[*i].id));
-
-        // PRE: all costs are positive 
-        // TODO implement weight for the graph
-
-        resetEdgeIndexUB();
-        int weightUB = 0;
-        BGL_FORALL_EDGES(e, UB, Gecode::Graph::Graph) {
-                // not using edgecosts[make_pair...] because operator[] inserts keys if missing
-                weightUB += edgecosts.find(make_pair(UB[source(e,UB)].id, UB[target(e,UB)].id ))->second ; 
-        }
-        int weightLB = 0;
-        BGL_FORALL_EDGES(e, LB, Gecode::Graph::Graph) {
-                weightLB += edgecosts.find(make_pair(LB[source(e,LB)].id, LB[target(e,LB)].id ))->second ;
-        }
-
-        return boost::make_tuple(ES_OK,weightLB,weightUB);
-}
-
-} }
-
-