2 #ifndef DUNE_AMG_GRAPH_HH
3 #define DUNE_AMG_GRAPH_HH
10 #include<dune/common/typetraits.hh>
11 #include<dune/common/iteratorfacades.hh>
13 #include<dune/common/propertymap.hh>
58 typedef typename M::block_type
Weight;
111 typename Matrix::row_type::ConstIterator>::Type
118 const typename M::block_type>::Type
147 typename M::block_type,
const typename M::block_type>::Type
257 typename M::block_type,
const typename M::block_type>::Type
433 template<
class G,
class T>
467 : firstEdge_(firstEdge)
472 : firstEdge_(emap.firstEdge_)
477 return edge-firstEdge_;
496 class EdgeIterator :
public RandomAccessIteratorFacade<EdgeIterator,const EdgeDescriptor>
551 :
public ForwardIteratorFacade<VertexIterator,const VertexDescriptor>
688 std::size_t noVertices_;
701 std::ptrdiff_t* start_;
703 std::ptrdiff_t* end_;
713 template<
class G,
class VP,
class VM=IdentityMap>
791 :
public SelectType<is_same<typename remove_const<C>::type,
793 typename Graph::VertexIterator,
794 typename Graph::ConstVertexIterator>::Type
802 typedef typename SelectType<is_same<typename remove_const<C>::type,
804 typename Graph::VertexIterator,
805 typename Graph::ConstVertexIterator>::Type
811 typedef typename SelectType<is_same<typename remove_const<C>::type,
813 typename Graph::EdgeIterator,
814 typename Graph::ConstEdgeIterator>::Type
845 typename SelectType<is_same<C,typename remove_const<C>::type>::value,
847 const VertexProperties&>::Type
961 std::vector<VertexProperties> vertexProperties_;
968 template<
class G,
class VP,
class EP,
class VM=IdentityMap,
class EM=IdentityMap>
1026 :
public SelectType<is_same<typename remove_const<C>::type,
1028 typename Graph::EdgeIterator,
1029 typename Graph::ConstEdgeIterator>::Type
1038 typedef typename SelectType<is_same<typename remove_const<C>::type,
1040 typename Graph::EdgeIterator,
1041 typename Graph::ConstEdgeIterator>::Type
1071 typename SelectType<is_same<C,typename remove_const<C>::type>::value,
1073 const EdgeProperties&>::Type
1128 :
public SelectType<is_same<typename remove_const<C>::type,
1130 typename Graph::VertexIterator,
1131 typename Graph::ConstVertexIterator>::Type
1139 typedef typename SelectType<is_same<typename remove_const<C>::type,
1141 typename Graph::VertexIterator,
1142 typename Graph::ConstVertexIterator>::Type
1173 typename SelectType<is_same<C,typename remove_const<C>::type>::value,
1175 const VertexProperties&>::Type
1258 const VertexDescriptor& target)
1260 return graph_.findEdge(source,target);
1327 const EdgeMap& emap=EdgeMap());
1338 std::vector<VertexProperties> vertexProperties_;
1342 std::vector<EdgeProperties> edgeProperties_;
1351 template<
typename G>
1389 return graph_->getVertexProperties(vertex);
1399 template<
typename G>
1414 typedef typename G::EdgeDescriptor
Edge;
1436 return graph_->getEdgeProperties(edge);
1453 template<
class G,
class V>
1454 int visitNeighbours(
const G& graph,
const typename G::VertexDescriptor& vertex,
1460 MatrixGraph<M>::MatrixGraph(M& matrix)
1463 if(matrix_.N()!=matrix_.M())
1464 DUNE_THROW(
ISTLError,
"Matrix has to have as many columns as rows!");
1466 start_ =
new EdgeDescriptor[matrix_.N()+1];
1468 typedef typename M::ConstIterator Iterator;
1469 Iterator
row = matrix_.begin();
1470 start_[row.index()] = 0;
1472 for(Iterator row=matrix_.begin(); row != matrix_.end(); ++
row)
1473 start_[row.index()+1] = start_[row.index()] + row->size();
1485 return start_[matrix_.N()];
1497 return matrix_.N()-1;
1501 typename MatrixGraph<M>::EdgeDescriptor
1503 const VertexDescriptor& target)
const
1505 typename M::ConstColIterator found =matrix_[source].find(target);
1506 if(found == matrix_[source].end())
1507 return std::numeric_limits<EdgeDescriptor>::max();
1508 std::size_t offset = found.offset();
1512 assert(offset<noEdges());
1514 return start_[source]+offset;
1532 MatrixGraph<M>::EdgeIteratorT<C>::EdgeIteratorT(
const VertexDescriptor& source,
const ColIterator& block,
1533 const ColIterator& end,
const EdgeDescriptor& edge)
1534 : source_(source), block_(block), blockEnd_(end), edge_(edge)
1536 if(block_!=blockEnd_ && block_.index() == source_){
1544 MatrixGraph<M>::EdgeIteratorT<C>::EdgeIteratorT(
const ColIterator& block)
1551 MatrixGraph<M>::EdgeIteratorT<C>::EdgeIteratorT(
const EdgeIteratorT<C1>& other)
1552 : source_(other.source_), block_(other.block_), blockEnd_(other.blockEnd_), edge_(other.edge_)
1558 inline typename MatrixGraph<M>::template EdgeIteratorT<C>::WeightType&
1559 MatrixGraph<M>::EdgeIteratorT<C>::weight()
const
1566 inline typename MatrixGraph<M>::template EdgeIteratorT<C>& MatrixGraph<M>::EdgeIteratorT<C>::operator++()
1571 if(block_!=blockEnd_ && block_.index() == source_){
1581 inline bool MatrixGraph<M>::EdgeIteratorT<C>::operator!=(
const typename MatrixGraph<M>::template EdgeIteratorT<
typename remove_const<C>::type>& other)
const
1583 return block_!=other.block_;
1588 inline bool MatrixGraph<M>::EdgeIteratorT<C>::operator!=(
const typename MatrixGraph<M>::template EdgeIteratorT<
const typename remove_const<C>::type>& other)
const
1590 return block_!=other.block_;
1597 return block_==other.block_;
1604 return block_==other.block_;
1609 inline typename MatrixGraph<M>::VertexDescriptor MatrixGraph<M>::EdgeIteratorT<C>::target()
const
1611 return block_.index();
1616 inline typename MatrixGraph<M>::VertexDescriptor MatrixGraph<M>::EdgeIteratorT<C>::source()
const
1623 inline const typename MatrixGraph<M>::EdgeDescriptor& MatrixGraph<M>::EdgeIteratorT<C>::operator*()
const
1630 inline const typename MatrixGraph<M>::EdgeDescriptor* MatrixGraph<M>::EdgeIteratorT<C>::operator->()
const
1637 MatrixGraph<M>::VertexIteratorT<C>::VertexIteratorT(C* graph,
1638 const VertexDescriptor& current)
1639 : graph_(graph), current_(current)
1645 MatrixGraph<M>::VertexIteratorT<C>::VertexIteratorT(
const VertexDescriptor& current)
1651 MatrixGraph<M>::VertexIteratorT<C>::VertexIteratorT(
const VertexIteratorT<MutableContainer>& other)
1652 : graph_(other.graph_), current_(other.current_)
1657 inline bool MatrixGraph<M>::VertexIteratorT<C>::operator!=(
const VertexIteratorT<MutableContainer>& other)
const
1659 return current_ != other.current_;
1664 inline bool MatrixGraph<M>::VertexIteratorT<C>::operator!=(
const VertexIteratorT<ConstContainer>& other)
const
1666 return current_ != other.current_;
1674 return current_ == other.current_;
1681 return current_ == other.current_;
1686 inline typename MatrixGraph<M>::template VertexIteratorT<C>& MatrixGraph<M>::VertexIteratorT<C>::operator++()
1694 inline typename MatrixGraph<M>::template VertexIteratorT<C>::WeightType&
1695 MatrixGraph<M>::VertexIteratorT<C>::weight()
const
1697 return graph_->matrix()[current_][current_];
1702 inline const typename MatrixGraph<M>::VertexDescriptor&
1703 MatrixGraph<M>::VertexIteratorT<C>::operator*()
const
1710 inline typename MatrixGraph<M>::template EdgeIteratorT<C>
1713 return graph_->beginEdges(current_);
1718 inline typename MatrixGraph<M>::template EdgeIteratorT<C>
1721 return graph_->endEdges(current_);
1725 inline typename MatrixGraph<M>::template VertexIteratorT<MatrixGraph<M> >
1728 return VertexIterator(
this,0);
1732 inline typename MatrixGraph<M>::template VertexIteratorT<MatrixGraph<M> >
1735 return VertexIterator(matrix_.N());
1740 inline typename MatrixGraph<M>::template VertexIteratorT<const MatrixGraph<M> >
1743 return ConstVertexIterator(
this, 0);
1747 inline typename MatrixGraph<M>::template VertexIteratorT<const MatrixGraph<M> >
1750 return ConstVertexIterator(matrix_.N());
1754 inline typename MatrixGraph<M>::template EdgeIteratorT<MatrixGraph<M> >
1757 return EdgeIterator(source, matrix_.operator[](source).begin(),
1758 matrix_.operator[](source).end(), start_[source]);
1762 inline typename MatrixGraph<M>::template EdgeIteratorT<MatrixGraph<M> >
1765 return EdgeIterator(matrix_.operator[](source).end());
1770 inline typename MatrixGraph<M>::template EdgeIteratorT<const MatrixGraph<M> >
1773 return ConstEdgeIterator(source, matrix_.operator[](source).begin(),
1774 matrix_.operator[](source).end(), start_[source]);
1778 inline typename MatrixGraph<M>::template EdgeIteratorT<const MatrixGraph<M> >
1781 return ConstEdgeIterator(matrix_.operator[](source).end());
1785 template<
class G,
class T>
1787 const EdgeDescriptor& edge)
1788 : source_(source), edge_(edge)
1792 template<
class G,
class T>
1797 template<
class G,
class T>
1800 return EdgeIndexMap(edges_);
1803 template<
class G,
class T>
1806 return other.edge_==edge_;
1809 template<
class G,
class T>
1816 template<
class G,
class T>
1823 template<
class G,
class T>
1829 template<
class G,
class T>
1835 template<
class G,
class T>
1842 template<
class G,
class T>
1848 template<
class G,
class T>
1851 return other.edge_-edge_;
1854 template<
class G,
class T>
1858 : graph_(graph), current_(current), end_(end)
1861 typedef typename T::const_iterator Iterator;
1863 for(Iterator vertex = graph_->excluded_.begin();
1864 current_ != end_ && *vertex;
1867 assert(current_ == end_ || !graph_->excluded_[current_]);
1870 template<
class G,
class T>
1875 template<
class G,
class T>
1880 while(current_ != end_ && graph_->excluded_[current_])
1883 assert(current_ == end_ || !graph_->excluded_[current_]);
1887 template<
class G,
class T>
1890 return current_==other.current_;
1893 template<
class G,
class T>
1899 template<
class G,
class T>
1902 return graph_->beginEdges(current_);
1905 template<
class G,
class T>
1908 return graph_->endEdges(current_);
1911 template<
class G,
class T>
1914 return VertexIterator(
this, 0, endVertex_);
1918 template<
class G,
class T>
1921 return VertexIterator(endVertex_);
1925 template<
class G,
class T>
1928 return EdgeIterator(source, edges_+start_[source]);
1931 template<
class G,
class T>
1934 return EdgeIterator(edges_+end_[source]);
1937 template<
class G,
class T>
1943 template<
class G,
class T>
1949 template<
class G,
class T>
1955 template<
class G,
class T>
1959 const EdgeDescriptor edge = std::lower_bound(edges_+start_[source], edges_+end_[source], target);
1960 if(edge==edges_+end_[source] || *edge!=target)
1961 return std::numeric_limits<EdgeDescriptor>::max();
1966 template<
class G,
class T>
1974 template<
class G,
class T>
1976 : excluded_(excluded), noVertices_(0), endVertex_(0), maxVertex_(graph.
maxVertex())
1978 start_ =
new std::ptrdiff_t[graph.noVertices()];
1979 end_ =
new std::ptrdiff_t[graph.noVertices()];
1980 edges_ =
new VertexDescriptor[graph.noEdges()];
1982 VertexDescriptor* edge=edges_;
1984 typedef typename Graph::ConstVertexIterator Iterator;
1985 Iterator endVertex=graph.end();
1987 for(Iterator vertex = graph.begin(); vertex != endVertex; ++vertex)
1988 if(excluded_[*vertex])
1989 start_[*vertex]=end_[*vertex]=-1;
1992 endVertex_ = std::max(*vertex, endVertex_);
1994 start_[*vertex] = edge-edges_;
1996 typedef typename Graph::ConstEdgeIterator Iterator;
1997 Iterator endEdge = vertex.end();
1999 for(Iterator iter=vertex.begin(); iter!= endEdge; ++iter)
2000 if(!excluded[iter.target()]){
2001 *edge = iter.target();
2005 end_[*vertex] = edge - edges_;
2008 std::sort(edges_+start_[*vertex], edge);
2010 noEdges_ = edge-edges_;
2014 template<
class G,
class V,
class VM>
2017 return graph_.noEdges();
2020 template<
class G,
class V,
class VM>
2021 inline typename VertexPropertiesGraph<G,V,VM>::EdgeIterator
2024 return graph_.beginEdges(source);
2027 template<
class G,
class V,
class VM>
2028 inline typename VertexPropertiesGraph<G,V,VM>::EdgeIterator
2031 return graph_.endEdges(source);
2034 template<
class G,
class V,
class VM>
2035 typename VertexPropertiesGraph<G,V,VM>::ConstEdgeIterator
2038 return graph_.beginEdges(source);
2041 template<
class G,
class V,
class VM>
2042 typename VertexPropertiesGraph<G,V,VM>::ConstEdgeIterator
2045 return graph_.endEdges(source);
2048 template<
class G,
class V,
class VM>
2050 VertexPropertiesGraph<G,V,VM>::VertexIteratorT<C>
2051 ::VertexIteratorT(
const Father& iter,
2053 : Father(iter), graph_(graph)
2056 template<
class G,
class V,
class VM>
2058 VertexPropertiesGraph<G,V,VM>::VertexIteratorT<C>
2059 ::VertexIteratorT(
const Father& iter)
2063 template<
class G,
class V,
class VM>
2066 VertexPropertiesGraph<G,V,VM>::VertexIteratorT<C>
2067 ::VertexIteratorT(
const VertexIteratorT<C1>& other)
2068 : Father(other), graph_(other.graph_)
2071 template<
class G,
class V,
class VM>
2075 inline VertexPropertiesGraph<G,V,VM>::VertexIteratorT<C>::properties()
const
2077 return graph_->getVertexProperties(Father::operator*());
2080 template<
class G,
class V,
class VM>
2084 typename G::EdgeIterator,
2085 typename G::ConstEdgeIterator>::Type
2088 return graph_->beginEdges(Father::operator*());
2091 template<
class G,
class V,
class VM>
2095 typename G::EdgeIterator,
2096 typename G::ConstEdgeIterator>::Type
2099 return graph_->endEdges(Father::operator*());
2102 template<
class G,
class V,
class VM>
2105 return VertexIterator(graph_.begin(),
this);
2108 template<
class G,
class V,
class VM>
2111 return VertexIterator(graph_.end());
2115 template<
class G,
class V,
class VM>
2118 return ConstVertexIterator(graph_.begin(),
this);
2121 template<
class G,
class V,
class VM>
2124 return ConstVertexIterator(graph_.end());
2127 template<
class G,
class V,
class VM>
2130 return vertexProperties_[vmap_[vertex]];
2133 template<
class G,
class V,
class VM>
2136 return vertexProperties_[vmap_[vertex]];
2139 template<
class G,
class V,
class VM>
2145 template<
class G,
class V,
class VM>
2148 return graph_.noVertices();
2152 template<
class G,
class V,
class VM>
2155 return graph_.maxVertex();
2158 template<
class G,
class V,
class VM>
2160 : graph_(graph), vmap_(vmap), vertexProperties_(vmap_[graph_.maxVertex()+1], V())
2163 template<
class G,
class V,
class E,
class VM,
class EM>
2165 PropertiesGraph<G,V,E,VM,EM>::EdgeIteratorT<C>::EdgeIteratorT(
const Father& iter,
2167 : Father(iter), graph_(graph)
2170 template<
class G,
class V,
class E,
class VM,
class EM>
2172 PropertiesGraph<G,V,E,VM,EM>::EdgeIteratorT<C>::EdgeIteratorT(
const Father& iter)
2176 template<
class G,
class V,
class E,
class VM,
class EM>
2179 PropertiesGraph<G,V,E,VM,EM>::EdgeIteratorT<C>::EdgeIteratorT(
const EdgeIteratorT<C1>& other)
2180 : Father(other), graph_(other.graph_)
2184 template<
class G,
class V,
class E,
class VM,
class EM>
2187 return graph_.noEdges();
2190 template<
class G,
class V,
class E,
class VM,
class EM>
2193 PropertiesGraph<G,V,E,VM,EM>::EdgeIteratorT<C>::properties()
const
2195 return graph_->getEdgeProperties(Father::operator*());
2198 template<
class G,
class V,
class E,
class VM,
class EM>
2199 inline typename PropertiesGraph<G,V,E,VM,EM>::EdgeIterator
2202 return EdgeIterator(graph_.beginEdges(source),
this);
2205 template<
class G,
class V,
class E,
class VM,
class EM>
2206 inline typename PropertiesGraph<G,V,E,VM,EM>::EdgeIterator
2209 return EdgeIterator(graph_.endEdges(source));
2212 template<
class G,
class V,
class E,
class VM,
class EM>
2213 typename PropertiesGraph<G,V,E,VM,EM>::ConstEdgeIterator
2216 return ConstEdgeIterator(graph_.beginEdges(source),
this);
2219 template<
class G,
class V,
class E,
class VM,
class EM>
2220 typename PropertiesGraph<G,V,E,VM,EM>::ConstEdgeIterator
2223 return ConstEdgeIterator(graph_.endEdges(source));
2226 template<
class G,
class V,
class E,
class VM,
class EM>
2228 PropertiesGraph<G,V,E,VM,EM>::VertexIteratorT<C>
2229 ::VertexIteratorT(
const Father& iter,
2231 : Father(iter), graph_(graph)
2234 template<
class G,
class V,
class E,
class VM,
class EM>
2236 PropertiesGraph<G,V,E,VM,EM>::VertexIteratorT<C>
2237 ::VertexIteratorT(
const Father& iter)
2241 template<
class G,
class V,
class E,
class VM,
class EM>
2244 PropertiesGraph<G,V,E,VM,EM>::VertexIteratorT<C>
2245 ::VertexIteratorT(
const VertexIteratorT<C1>& other)
2246 : Father(other), graph_(other.graph_)
2249 template<
class G,
class V,
class E,
class VM,
class EM>
2253 PropertiesGraph<G,V,E,VM,EM>::VertexIteratorT<C>::properties()
const
2255 return graph_->getVertexProperties(Father::operator*());
2258 template<
class G,
class V,
class E,
class VM,
class EM>
2260 inline typename PropertiesGraph<G,V,E,VM,EM>::template EdgeIteratorT<C>
2263 return graph_->beginEdges(Father::operator*());
2266 template<
class G,
class V,
class E,
class VM,
class EM>
2268 inline typename PropertiesGraph<G,V,E,VM,EM>::template EdgeIteratorT<C>
2271 return graph_->endEdges(Father::operator*());
2274 template<
class G,
class V,
class E,
class VM,
class EM>
2277 return VertexIterator(graph_.begin(),
this);
2280 template<
class G,
class V,
class E,
class VM,
class EM>
2283 return VertexIterator(graph_.end());
2287 template<
class G,
class V,
class E,
class VM,
class EM>
2290 return ConstVertexIterator(graph_.begin(),
this);
2293 template<
class G,
class V,
class E,
class VM,
class EM>
2296 return ConstVertexIterator(graph_.end());
2299 template<
class G,
class V,
class E,
class VM,
class EM>
2302 return vertexProperties_[vmap_[vertex]];
2305 template<
class G,
class V,
class E,
class VM,
class EM>
2308 return vertexProperties_[vmap_[vertex]];
2311 template<
class G,
class V,
class E,
class VM,
class EM>
2314 return edgeProperties_[emap_[edge]];
2317 template<
class G,
class V,
class E,
class VM,
class EM>
2320 return edgeProperties_[emap_[edge]];
2323 template<
class G,
class V,
class E,
class VM,
class EM>
2325 const VertexDescriptor& target)
2327 return getEdgeProperties(graph_.findEdge(source,target));
2330 template<
class G,
class V,
class E,
class VM,
class EM>
2332 const VertexDescriptor& target)
const
2334 return getEdgeProperties(graph_.findEdge(source,target));
2337 template<
class G,
class V,
class E,
class VM,
class EM>
2343 template<
class G,
class V,
class E,
class VM,
class EM>
2346 return graph_.noVertices();
2350 template<
class G,
class V,
class E,
class VM,
class EM>
2353 return graph_.maxVertex();
2356 template<
class G,
class V,
class E,
class VM,
class EM>
2358 : graph_(graph), vmap_(vmap), vertexProperties_(vmap_[graph_.maxVertex()+1], V()),
2359 emap_(emap), edgeProperties_(graph_.noEdges(), E())
2362 template<
class G,
class V>
2363 inline int visitNeighbours(
const G& graph,
const typename G::VertexDescriptor& vertex,
2366 typedef typename G::ConstEdgeIterator iterator;
2367 const iterator end = graph.endEdges(vertex);
2369 for(iterator edge = graph.beginEdges(vertex); edge != end; ++edge, ++noNeighbours)
2371 return noNeighbours;