TNL::Graphs Namespace Reference

Graph algorithms and data structures. More...

Classes
struct	DirectedGraph
	Type tag for directed graphs. More...
struct	Edge
	Represents a weighted edge in a graph. More...
struct	Graph
	Graph class represents a mathematical graph using an adjacency matrix. More...
struct	GraphBase
	Graph class represents a mathematical graph using an adjacency matrix. More...
struct	GraphOrientation
	Template structure for specifying graph orientation (directed or undirected). More...
struct	GraphVertexView
	View type for accessing individual graph vertices and their edges. More...
struct	GraphVertexView< Matrices::DenseMatrixView< Real, Device, Index, Organization >, GraphType_ >
	Specialization of GraphVertexView for dense adjacency matrices. More...
struct	GraphVertexView< Matrices::SparseMatrixView< Real, Device, Index, MatrixType_, SegmentsView, ComputeRealType >, GraphType_ >
	Specialization of GraphVertexView for sparse adjacency matrices. More...
struct	GraphView
	View type for Graph class. More...
struct	UndirectedGraph
	Type tag for undirected graphs. More...

Functions
template<typename Graph, typename Function>
void	forAllEdges (const Graph &graph, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over all edges of all graph vertices of constant graph and applies the specified lambda function.
template<typename Graph, typename Function>
void	forAllEdges (Graph &graph, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over all edges of all graph vertices and applies the specified lambda function.
template<typename Graph, typename Condition, typename Function>
void	forAllEdgesIf (const Graph &graph, Condition &&condition, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over all edges of all graph vertices based on a condition.
template<typename Graph, typename Condition, typename Function>
void	forAllEdgesIf (Graph &graph, Condition &&condition, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over all edges of all graph vertices based on a condition.
template<typename Graph, typename Function>
void	forAllVertices (const Graph &graph, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over all graph vertices and applies the given lambda function to each vertex. This function is for constant matrices.
template<typename Graph, typename Function>
void	forAllVertices (Graph &graph, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over all graph vertices and applies the given lambda function to each vertex.
template<typename Graph, typename VertexCondition, typename Function>
void	forAllVerticesIf (const Graph &graph, VertexCondition &&vertexCondition, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over all graph vertices, applying a condition to determine whether each vertex should be processed. This function is for constant matrices.
template<typename Graph, typename VertexCondition, typename Function>
void	forAllVerticesIf (Graph &graph, VertexCondition &&vertexCondition, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over all graph vertices, applying a condition to determine whether each vertex should be processed.
template<typename Graph, typename Array, typename Function>
void	forEdges (const Graph &graph, const Array &vertexIndexes, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over all edges of graph vertices with the given indexes and applies the specified lambda function. This function is for constant matrices.
template<typename Graph, typename Array, typename IndexBegin, typename IndexEnd, typename Function>
void	forEdges (const Graph &graph, const Array &vertexIndexes, IndexBegin begin, IndexEnd end, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over all edges of graph vertices with the given indexes and applies the specified lambda function. This function is for constant matrices.
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Function>
void	forEdges (const Graph &graph, IndexBegin begin, IndexEnd end, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over all edges of constant graph in the given range of graph vertices and applies the specified lambda function.
template<typename Graph, typename Array, typename Function>
void	forEdges (Graph &graph, const Array &vertexIndexes, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over all edges of graph vertices with the given indexes and applies the specified lambda function.
template<typename Graph, typename Array, typename IndexBegin, typename IndexEnd, typename Function>
void	forEdges (Graph &graph, const Array &vertexIndexes, IndexBegin begin, IndexEnd end, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over all edges of graph vertices with the given indexes and applies the specified lambda function.
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Function>
void	forEdges (Graph &graph, IndexBegin begin, IndexEnd end, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over all edges in the given range of graph vertices and applies the specified lambda function.
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Condition, typename Function>
void	forEdgesIf (const Graph &graph, IndexBegin begin, IndexEnd end, Condition &&condition, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over all edges in a given range of vertices based on a condition. This function is for constant matrices.
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Condition, typename Function>
void	forEdgesIf (Graph &graph, IndexBegin begin, IndexEnd end, Condition &&condition, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over all edges in a given range of vertices based on a condition.
template<typename Graph, typename Array, typename Function, typename T = std::enable_if_t< IsArrayType< Array >::value >>
void	forVertices (const Graph &graph, const Array &vertexIndexes, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over graph vertices with the given indexes and applies the specified lambda function to each vertex. This function is for constant matrices.
template<typename Graph, typename Array, typename IndexBegin, typename IndexEnd, typename Function, typename T = std::enable_if_t< IsArrayType< Array >::value && std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>
void	forVertices (const Graph &graph, const Array &vertexIndexes, IndexBegin begin, IndexEnd end, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over graph vertices with the given indexes and applies the specified lambda function to each vertex. This function is for constant matrices.
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Function, typename T = std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>
void	forVertices (const Graph &graph, IndexBegin begin, IndexEnd end, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over graph vertices within the specified range of vertex indexes and applies the given lambda function to each vertex. This function is for constant matrices.
template<typename Graph, typename Array, typename Function, typename T = std::enable_if_t< IsArrayType< Array >::value >>
void	forVertices (Graph &graph, const Array &vertexIndexes, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over graph vertices with the given indexes and applies the specified lambda function to each vertex.
template<typename Graph, typename Array, typename IndexBegin, typename IndexEnd, typename Function, typename T = std::enable_if_t< IsArrayType< Array >::value && std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>
void	forVertices (Graph &graph, const Array &vertexIndexes, IndexBegin begin, IndexEnd end, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over graph vertices with the given indexes and applies the specified lambda function to each vertex.
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Function, typename T = std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>
void	forVertices (Graph &graph, IndexBegin begin, IndexEnd end, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over graph vertices within the specified range of vertex indexes and applies the given lambda function to each vertex.
template<typename Graph, typename IndexBegin, typename IndexEnd, typename VertexCondition, typename Function, typename T = std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>
void	forVerticesIf (const Graph &graph, IndexBegin begin, IndexEnd end, VertexCondition &&vertexCondition, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over vertices within the given range of vertex indexes, applying a condition to determine whether each vertex should be processed. This function is for constant matrices.
template<typename Graph, typename IndexBegin, typename IndexEnd, typename VertexCondition, typename Function, typename T = std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>
void	forVerticesIf (Graph &graph, IndexBegin begin, IndexEnd end, VertexCondition &&vertexCondition, Function &&function, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Iterates in parallel over vertices within the given range of vertex indexes, applying a condition to determine whether each vertex should be processed.
template<typename Graph>
Graph::ValueType	getTotalWeight (const Graph &graph)
	Computes the total weight of all edges in the graph.
constexpr std::false_type	isGraph (...)
	This checks if given type is matrix.
template<typename Value, typename Device, typename Index, typename Orientation, template< typename, typename, typename > class Segments, typename AdjacencyMatrix>
constexpr std::true_type	isGraph (const Graph< Value, Device, Index, Orientation, Segments, AdjacencyMatrix > &)
template<typename Value, typename Device, typename Index, typename Orientation, typename AdjacencyMatrix>
File &	operator<< (File &&file, const GraphBase< Value, Device, Index, Orientation, AdjacencyMatrix > &graph)
	Serialization of graphs into binary files.
template<typename Value, typename Device, typename Index, typename Orientation, typename AdjacencyMatrix>
File &	operator<< (File &file, const GraphBase< Value, Device, Index, Orientation, AdjacencyMatrix > &graph)
	Serialization of graphs into binary files.
template<typename Real, typename Index>
std::ostream &	operator<< (std::ostream &os, const Edge< Real, Index > &edge)
	Stream output operator for Edge.
template<typename Value, typename Device, typename Index, typename Orientation, typename AdjacencyMatrix>
std::ostream &	operator<< (std::ostream &os, const GraphBase< Value, Device, Index, Orientation, AdjacencyMatrix > &graph)
	Output stream operator for the Graph class.
template<typename Value, typename Device, typename Index, typename Orientation, template< typename, typename, typename > class Segments, typename AdjacencyMatrix>
File &	operator>> (File &&file, Graph< Value, Device, Index, Orientation, Segments, AdjacencyMatrix > &graph)
	Deserialization of graphs from binary files.
template<typename Value, typename Device, typename Index, typename Orientation, template< typename, typename, typename > class Segments, typename AdjacencyMatrix>
File &	operator>> (File &file, Graph< Value, Device, Index, Orientation, Segments, AdjacencyMatrix > &graph)
	Deserialization of graphs from binary files.
template<typename Graph, typename Fetch, typename Reduction, typename Store, typename FetchValue>
void	reduceAllVertices (const Graph &graph, Fetch &&fetch, Reduction &&reduction, Store &&store, const FetchValue &identity, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over all vertices (const version).
template<typename Graph, typename Fetch, typename Reduction, typename Store>
void	reduceAllVertices (const Graph &graph, Fetch &&fetch, Reduction &&reduction, Store &&store, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over all vertices with automatic identity deduction (const version).
template<typename Graph, typename Fetch, typename Reduction, typename Store, typename FetchValue>
void	reduceAllVertices (Graph &graph, Fetch &&fetch, Reduction &&reduction, Store &&store, const FetchValue &identity, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over all vertices.
template<typename Graph, typename Fetch, typename Reduction, typename Store>
void	reduceAllVertices (Graph &graph, Fetch &&fetch, Reduction &&reduction, Store &&store, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over all vertices with automatic identity deduction.
template<typename Graph, typename Condition, typename Fetch, typename Reduction, typename Store, typename FetchValue>
Graph::IndexType	reduceAllVerticesIf (const Graph &graph, Condition &&condition, Fetch &&fetch, Reduction &&reduction, Store &&store, const FetchValue &identity, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over all vertices based on a condition (const version).
template<typename Graph, typename Condition, typename Fetch, typename Reduction, typename Store>
Graph::IndexType	reduceAllVerticesIf (const Graph &graph, Condition &&condition, Fetch &&fetch, Reduction &&reduction, Store &&store, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over all vertices based on a condition with automatic identity deduction (const version).
template<typename Graph, typename Condition, typename Fetch, typename Reduction, typename Store, typename FetchValue>
Graph::IndexType	reduceAllVerticesIf (Graph &graph, Condition &&condition, Fetch &&fetch, Reduction &&reduction, Store &&store, const FetchValue &identity, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over all vertices based on a condition.
template<typename Graph, typename Condition, typename Fetch, typename Reduction, typename Store>
Graph::IndexType	reduceAllVerticesIf (Graph &graph, Condition &&condition, Fetch &&fetch, Reduction &&reduction, Store &&store, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over all vertices based on a condition with automatic identity deduction.
template<typename Graph, typename Fetch, typename Reduction, typename Store, typename FetchValue>
void	reduceAllVerticesWithArgument (const Graph &graph, Fetch &&fetch, Reduction &&reduction, Store &&store, const FetchValue &identity, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over all vertices while returning also the position of the edge of interest (const version).
template<typename Graph, typename Fetch, typename Reduction, typename Store>
void	reduceAllVerticesWithArgument (const Graph &graph, Fetch &&fetch, Reduction &&reduction, Store &&store, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over all vertices while returning also the position of the edge of interest with automatic identity deduction (const version).
template<typename Graph, typename Fetch, typename Reduction, typename Store, typename FetchValue>
void	reduceAllVerticesWithArgument (Graph &graph, Fetch &&fetch, Reduction &&reduction, Store &&store, const FetchValue &identity, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over all vertices while returning also the position of the edge of interest.
template<typename Graph, typename Fetch, typename Reduction, typename Store>
void	reduceAllVerticesWithArgument (Graph &graph, Fetch &&fetch, Reduction &&reduction, Store &&store, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over all vertices while returning also the position of the edge of interest with automatic identity deduction.
template<typename Graph, typename Condition, typename Fetch, typename Reduction, typename Store, typename FetchValue = decltype( std::declval< Fetch >()( 0, 0, std::declval< typename Graph::RealType >() ) )>
Graph::IndexType	reduceAllVerticesWithArgumentIf (const Graph &graph, Condition &&condition, Fetch &&fetch, Reduction &&reduction, Store &&store, const FetchValue &identity, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over all vertices based on a condition while returning also the position of the edge of interest (const version).
template<typename Graph, typename Condition, typename Fetch, typename Reduction, typename Store>
Graph::IndexType	reduceAllVerticesWithArgumentIf (const Graph &graph, Condition &&condition, Fetch &&fetch, Reduction &&reduction, Store &&store, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over all vertices based on a condition while returning also the position of the edge of interest with automatic identity deduction (const version).
template<typename Graph, typename Condition, typename Fetch, typename Reduction, typename Store, typename FetchValue = decltype( std::declval< Fetch >()( 0, 0, std::declval< typename Graph::RealType >() ) )>
Graph::IndexType	reduceAllVerticesWithArgumentIf (Graph &graph, Condition &&condition, Fetch &&fetch, Reduction &&reduction, Store &&store, const FetchValue &identity, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over all vertices based on a condition while returning also the position of the edge of interest.
template<typename Graph, typename Condition, typename Fetch, typename Reduction, typename Store>
Graph::IndexType	reduceAllVerticesWithArgumentIf (Graph &graph, Condition &&condition, Fetch &&fetch, Reduction &&reduction, Store &&store, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over all vertices based on a condition while returning also the position of the edge of interest with automatic identity deduction.
template<typename Graph, typename Array, typename Fetch, typename Reduction, typename Store, typename FetchValue, typename T = typename std::enable_if_t< IsArrayType< Array >::value >>
void	reduceVertices (const Graph &graph, const Array &vertexIndexes, Fetch &&fetch, Reduction &&reduction, Store &&store, const FetchValue &identity, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within graph vertices specified by a given set of vertex indexes (const version).
template<typename Graph, typename Array, typename Fetch, typename Reduction, typename Store, typename T = typename std::enable_if_t< IsArrayType< Array >::value >>
void	reduceVertices (const Graph &graph, const Array &vertexIndexes, Fetch &&fetch, Reduction &&reduction, Store &&store, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within graph vertices specified by a given set of vertex indexes with automatic identity deduction (const version).
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Fetch, typename Reduction, typename Store, typename FetchValue, typename T = typename std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>
void	reduceVertices (const Graph &graph, IndexBegin begin, IndexEnd end, Fetch &&fetch, Reduction &&reduction, Store &&store, const FetchValue &identity, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over a given range of vertex indexes (const version).
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Fetch, typename Reduction, typename Store, typename T = typename std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>
void	reduceVertices (const Graph &graph, IndexBegin begin, IndexEnd end, Fetch &&fetch, Reduction &&reduction, Store &&store, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over a given range of vertex indexes with automatic identity deduction (const version).
template<typename Graph, typename Array, typename Fetch, typename Reduction, typename Store, typename FetchValue, typename T = typename std::enable_if_t< IsArrayType< Array >::value >>
void	reduceVertices (Graph &graph, const Array &vertexIndexes, Fetch &&fetch, Reduction &&reduction, Store &&store, const FetchValue &identity, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within graph vertices specified by a given set of vertex indexes.
template<typename Graph, typename Array, typename Fetch, typename Reduction, typename Store, typename T = typename std::enable_if_t< IsArrayType< Array >::value >>
void	reduceVertices (Graph &graph, const Array &vertexIndexes, Fetch &&fetch, Reduction &&reduction, Store &&store, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within graph vertices specified by a given set of vertex indexes with automatic identity deduction.
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Fetch, typename Reduction, typename Store, typename FetchValue, typename T = typename std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>
void	reduceVertices (Graph &graph, IndexBegin begin, IndexEnd end, Fetch &&fetch, Reduction &&reduction, Store &&store, const FetchValue &identity, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over a given range of vertex indexes.
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Fetch, typename Reduction, typename Store, typename T = typename std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>
void	reduceVertices (Graph &graph, IndexBegin begin, IndexEnd end, Fetch &&fetch, Reduction &&reduction, Store &&store, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over a given range of vertex indexes with automatic identity deduction.
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Condition, typename Fetch, typename Reduction, typename Store, typename FetchValue>
Graph::IndexType	reduceVerticesIf (const Graph &graph, IndexBegin begin, IndexEnd end, Condition &&condition, Fetch &&fetch, Reduction &&reduction, Store &&store, const FetchValue &identity, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over a given range of vertex indexes based on a condition (const version).
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Condition, typename Fetch, typename Reduction, typename Store>
Graph::IndexType	reduceVerticesIf (const Graph &graph, IndexBegin begin, IndexEnd end, Condition &&condition, Fetch &&fetch, Reduction &&reduction, Store &&store, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over a given range of vertex indexes based on a condition with automatic identity deduction (const version).
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Condition, typename Fetch, typename Reduction, typename Store, typename FetchValue>
Graph::IndexType	reduceVerticesIf (Graph &graph, IndexBegin begin, IndexEnd end, Condition &&condition, Fetch &&fetch, Reduction &&reduction, Store &&store, const FetchValue &identity, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over a given range of vertex indexes based on a condition.
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Condition, typename Fetch, typename Reduction, typename Store>
Graph::IndexType	reduceVerticesIf (Graph &graph, IndexBegin begin, IndexEnd end, Condition &&condition, Fetch &&fetch, Reduction &&reduction, Store &&store, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over a given range of vertex indexes based on a condition with automatic identity deduction.
template<typename Graph, typename Array, typename Fetch, typename Reduction, typename Store, typename FetchValue, typename T = typename std::enable_if_t< IsArrayType< Array >::value >>
void	reduceVerticesWithArgument (const Graph &graph, const Array &vertexIndexes, Fetch &&fetch, Reduction &&reduction, Store &&store, const FetchValue &identity, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within graph vertices specified by a given set of vertex indexes while returning also the position of the edge of interest (const version).
template<typename Graph, typename Array, typename Fetch, typename Reduction, typename Store, typename T = typename std::enable_if_t< IsArrayType< Array >::value >>
void	reduceVerticesWithArgument (const Graph &graph, const Array &vertexIndexes, Fetch &&fetch, Reduction &&reduction, Store &&store, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within graph vertices specified by a given set of vertex indexes while returning also the position of the edge of interest with automatic identity deduction (const version).
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Fetch, typename Reduction, typename Store, typename FetchValue, typename T = typename std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>
void	reduceVerticesWithArgument (const Graph &graph, IndexBegin begin, IndexEnd end, Fetch &&fetch, Reduction &&reduction, Store &&store, const FetchValue &identity, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over a given range of vertex indexes while returning also the position of the edge of interest (const version).
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Fetch, typename Reduction, typename Store, typename T = typename std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>
void	reduceVerticesWithArgument (const Graph &graph, IndexBegin begin, IndexEnd end, Fetch &&fetch, Reduction &&reduction, Store &&store, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over a given range of vertex indexes while returning also the position of the edge of interest with automatic identity deduction (const version).
template<typename Graph, typename Array, typename Fetch, typename Reduction, typename Store, typename FetchValue, typename T = typename std::enable_if_t< IsArrayType< Array >::value >>
void	reduceVerticesWithArgument (Graph &graph, const Array &vertexIndexes, Fetch &&fetch, Reduction &&reduction, Store &&store, const FetchValue &identity, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within graph vertices specified by a given set of vertex indexes while returning also the position of the edge of interest.
template<typename Graph, typename Array, typename Fetch, typename Reduction, typename Store, typename T = typename std::enable_if_t< IsArrayType< Array >::value >>
void	reduceVerticesWithArgument (Graph &graph, const Array &vertexIndexes, Fetch &&fetch, Reduction &&reduction, Store &&store, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within graph vertices specified by a given set of vertex indexes while returning also the position of the edge of interest with automatic identity deduction.
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Fetch, typename Reduction, typename Store, typename FetchValue, typename T = typename std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>
void	reduceVerticesWithArgument (Graph &graph, IndexBegin begin, IndexEnd end, Fetch &&fetch, Reduction &&reduction, Store &&store, const FetchValue &identity, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over a given range of vertex indexes while returning also the position of the edge of interest.
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Fetch, typename Reduction, typename Store, typename T = typename std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>
void	reduceVerticesWithArgument (Graph &graph, IndexBegin begin, IndexEnd end, Fetch &&fetch, Reduction &&reduction, Store &&store, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over a given range of vertex indexes while returning also the position of the edge of interest with automatic identity deduction.
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Condition, typename Fetch, typename Reduction, typename Store, typename FetchValue = decltype( std::declval< Fetch >()( 0, 0, std::declval< typename Graph::RealType >() ) )>
Graph::IndexType	reduceVerticesWithArgumentIf (const Graph &graph, IndexBegin begin, IndexEnd end, Condition &&condition, Fetch &&fetch, Reduction &&reduction, Store &&store, const FetchValue &identity, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over a given range of vertex indexes based on a condition while returning also the position of the edge of interest (const version).
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Condition, typename Fetch, typename Reduction, typename Store>
Graph::IndexType	reduceVerticesWithArgumentIf (const Graph &graph, IndexBegin begin, IndexEnd end, Condition &&condition, Fetch &&fetch, Reduction &&reduction, Store &&store, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over a given range of vertex indexes based on a condition while returning also the position of the edge of interest with automatic identity deduction (const version).
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Condition, typename Fetch, typename Reduction, typename Store, typename FetchValue = decltype( std::declval< Fetch >()( 0, 0, std::declval< typename Graph::RealType >() ) )>
Graph::IndexType	reduceVerticesWithArgumentIf (Graph &graph, IndexBegin begin, IndexEnd end, Condition &&condition, Fetch &&fetch, Reduction &&reduction, Store &&store, const FetchValue &identity, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over a given range of vertex indexes based on a condition while returning also the position of the edge of interest.
template<typename Graph, typename IndexBegin, typename IndexEnd, typename Condition, typename Fetch, typename Reduction, typename Store>
Graph::IndexType	reduceVerticesWithArgumentIf (Graph &graph, IndexBegin begin, IndexEnd end, Condition &&condition, Fetch &&fetch, Reduction &&reduction, Store &&store, TNL::Algorithms::Segments::LaunchConfiguration launchConfig=TNL::Algorithms::Segments::LaunchConfiguration())
	Performs parallel reduction within each graph vertex over a given range of vertex indexes based on a condition while returning also the position of the edge of interest with automatic identity deduction.

Detailed Description

Graph algorithms and data structures.

Function Documentation

forAllEdges() [1/2]

template<typename Graph, typename Function>

void TNL::Graphs::forAllEdges	(	const Graph &	graph,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over all edges of all graph vertices of constant graph and applies the specified lambda function.

See also: Overview of Graph Traversal Functions

Template Parameters

Graph	The type of the graph.
Function	The type of the lambda function to be applied to each edge.

Parameters

graph	The graph whose edges will be processed using the lambda function.
function	Lambda function to be applied to each edge. See Traversal Function (Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void
forAllEdgesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Traverse edges in range [1, 4) and modify them.
    */
   auto modifyEdge = [] __cuda_callable__( int sourceIdx, int localIdx, int& targetIdx, float& weight ) mutable
   {
      targetIdx = ( targetIdx + 1 ) % 5;
      weight += 5;
   };
   TNL::Graphs::forEdges( graph, 1, 4, modifyEdge );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forAllEdgesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forAllEdgesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     4:65  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     4:65  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 

forAllEdges() [2/2]

template<typename Graph, typename Function>

void TNL::Graphs::forAllEdges	(	Graph &	graph,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over all edges of all graph vertices and applies the specified lambda function.

See also: Overview of Graph Traversal Functions

Template Parameters

Graph	The type of the graph.
Function	The type of the lambda function to be applied to each edge.

Parameters

graph	The graph whose edges will be processed using the lambda function.
function	Lambda function to be applied to each edge. See Traversal Function (Non-Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void
forAllEdgesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Traverse edges in range [1, 4) and modify them.
    */
   auto modifyEdge = [] __cuda_callable__( int sourceIdx, int localIdx, int& targetIdx, float& weight ) mutable
   {
      targetIdx = ( targetIdx + 1 ) % 5;
      weight += 5;
   };
   TNL::Graphs::forEdges( graph, 1, 4, modifyEdge );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forAllEdgesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forAllEdgesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     4:65  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     4:65  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 

forAllEdgesIf() [1/2]

template<typename Graph, typename Condition, typename Function>

void TNL::Graphs::forAllEdgesIf	(	const Graph &	graph,
		Condition &&	condition,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over all edges of all graph vertices based on a condition.

See also: Overview of Graph Traversal Functions

This function is for constant matrices.

For each graph vertex, a condition lambda function is evaluated based on the vertex index. If the condition lambda function returns true, all edges of the vertex are traversed, and the specified lambda function is applied to each edge. If the condition lambda function returns false, the vertex is skipped.

Template Parameters

Graph	The type of the graph.
Condition	The type of the condition lambda function.
Function	The type of the lambda function to be applied to each edge.

Parameters

graph	The graph whose edges will be processed using the lambda function.
condition	Lambda function to check vertex condition. See Condition Lambda.
function	Lambda function to be applied to each edge. See Traversal Function (Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void
forAllEdgesIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Define a condition: process only vertices with even indices.
    */
   auto condition = [] __cuda_callable__( int vertexIdx ) -> bool
   {
      return vertexIdx % 2 == 0;
   };

   /***
    * Traverse edges only from vertices that satisfy the condition.
    */
   auto modifyEdge = [] __cuda_callable__( int sourceIdx, int localIdx, int targetIdx, float weight ) mutable
   {
      targetIdx = ( targetIdx + 1 ) % 5;
      weight += 5;
   };
   TNL::Graphs::forAllEdgesIf( graph, condition, modifyEdge );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forAllEdgesIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forAllEdgesIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 

forAllEdgesIf() [2/2]

template<typename Graph, typename Condition, typename Function>

void TNL::Graphs::forAllEdgesIf	(	Graph &	graph,
		Condition &&	condition,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over all edges of all graph vertices based on a condition.

See also: Overview of Graph Traversal Functions

For each graph vertex, a condition lambda function is evaluated based on the vertex index. If the condition lambda function returns true, all edges of the vertex are traversed, and the specified lambda function is applied to each edge. If the condition lambda function returns false, the vertex is skipped.

Template Parameters

Graph	The type of the graph.
Condition	The type of the condition lambda function.
Function	The type of the lambda function to be applied to each edge.

Parameters

graph	The graph whose edges will be processed using the lambda function.
condition	Lambda function to check vertex condition. See Condition Lambda.
function	Lambda function to be applied to each edge. See Traversal Function (Non-Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void
forAllEdgesIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Define a condition: process only vertices with even indices.
    */
   auto condition = [] __cuda_callable__( int vertexIdx ) -> bool
   {
      return vertexIdx % 2 == 0;
   };

   /***
    * Traverse edges only from vertices that satisfy the condition.
    */
   auto modifyEdge = [] __cuda_callable__( int sourceIdx, int localIdx, int targetIdx, float weight ) mutable
   {
      targetIdx = ( targetIdx + 1 ) % 5;
      weight += 5;
   };
   TNL::Graphs::forAllEdgesIf( graph, condition, modifyEdge );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forAllEdgesIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forAllEdgesIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 

forAllVertices() [1/2]

template<typename Graph, typename Function>

void TNL::Graphs::forAllVertices	(	const Graph &	graph,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over all graph vertices and applies the given lambda function to each vertex. This function is for constant matrices.

See also: Overview of Graph Traversal Functions

Template Parameters

Graph	The type of the graph.
Function	The type of the lambda function to be executed on each vertex.

Parameters

graph	The graph on which the lambda function will be applied.
function	Lambda function to be applied to each vertex. See Vertex Traversal Function (Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void
forVerticesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Traverse vertices in range [1, 4) and modify their edges.
    */
   auto processVertex = [] __cuda_callable__( typename GraphType::VertexView vertex ) mutable
   {
      for( int i = 0; i < vertex.getDegree(); i++ )
         vertex.setEdge( i, ( vertex.getTargetIndex( i ) + 1 ) % 5, vertex.getEdgeWeight( i ) + 5 );
   };
   TNL::Graphs::forVertices( graph, 1, 4, processVertex );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forVerticesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forVerticesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     4:65  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     4:65  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 

forAllVertices() [2/2]

template<typename Graph, typename Function>

void TNL::Graphs::forAllVertices	(	Graph &	graph,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over all graph vertices and applies the given lambda function to each vertex.

See also: Overview of Graph Traversal Functions

Template Parameters

Graph	The type of the graph.
Function	The type of the lambda function to be executed on each vertex.

Parameters

graph	The graph on which the lambda function will be applied.
function	Lambda function to be applied to each vertex. See Vertex Traversal Function (Non-Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void
forVerticesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Traverse vertices in range [1, 4) and modify their edges.
    */
   auto processVertex = [] __cuda_callable__( typename GraphType::VertexView vertex ) mutable
   {
      for( int i = 0; i < vertex.getDegree(); i++ )
         vertex.setEdge( i, ( vertex.getTargetIndex( i ) + 1 ) % 5, vertex.getEdgeWeight( i ) + 5 );
   };
   TNL::Graphs::forVertices( graph, 1, 4, processVertex );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forVerticesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forVerticesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     4:65  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     4:65  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 

forAllVerticesIf() [1/2]

template<typename Graph, typename VertexCondition, typename Function>

void TNL::Graphs::forAllVerticesIf	(	const Graph &	graph,
		VertexCondition &&	vertexCondition,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over all graph vertices, applying a condition to determine whether each vertex should be processed. This function is for constant matrices.

See also: Overview of Graph Traversal Functions

For each vertex, a condition lambda function is evaluated based on the vertex index. If the condition lambda function returns true, the specified lambda function is executed for the vertex. If the condition lambda function returns false, the vertex is skipped.

Template Parameters

Graph	The type of the graph.
VertexCondition	The type of the condition lambda function.
Function	The type of the lambda function to be executed on each vertex.

Parameters

graph	The graph on which the lambda function will be applied.
vertexCondition	Lambda function to check vertex condition. See Condition Lambda.
function	Lambda function to be applied to each vertex. See Vertex Traversal Function (Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void
forAllVerticesIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                        { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                        { 2, 3, 60.0 },
          { 3, 0, 70.0 },                               { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Define a condition: process only vertices with more than one edge.
    */
   auto condition = [ = ] __cuda_callable__( int vertexIdx ) -> bool
   {
      return graph.getVertexDegree( vertexIdx ) > 1;
   };

   /***
    * Traverse vertices that satisfy the condition.
    */
   auto processVertex = [] __cuda_callable__( typename GraphType::VertexView vertex ) mutable
   {
      for( int i = 0; i < vertex.getDegree(); i++ )
         vertex.setEdge( i, ( vertex.getTargetIndex( i ) + 1 ) % 5, vertex.getEdgeWeight( i ) + 5 );
   };
   TNL::Graphs::forAllVerticesIf( graph, condition, processVertex );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forAllVerticesIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forAllVerticesIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     2:15      3:25  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     3:60  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     2:15      3:25  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     3:60  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 

forAllVerticesIf() [2/2]

template<typename Graph, typename VertexCondition, typename Function>

void TNL::Graphs::forAllVerticesIf	(	Graph &	graph,
		VertexCondition &&	vertexCondition,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over all graph vertices, applying a condition to determine whether each vertex should be processed.

See also: Overview of Graph Traversal Functions

For each vertex, a condition lambda function is evaluated based on the vertex index. If the condition lambda function returns true, the specified lambda function is executed for the vertex. If the condition lambda function returns false, the vertex is skipped.

Template Parameters

Graph	The type of the graph.
VertexCondition	The type of the condition lambda function.
Function	The type of the lambda function to be executed on each vertex.

Parameters

graph	The graph on which the lambda function will be applied.
vertexCondition	Lambda function to check vertex condition. See Condition Lambda.
function	Lambda function to be applied to each vertex. See Vertex Traversal Function (Non-Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void
forAllVerticesIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                        { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                        { 2, 3, 60.0 },
          { 3, 0, 70.0 },                               { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Define a condition: process only vertices with more than one edge.
    */
   auto condition = [ = ] __cuda_callable__( int vertexIdx ) -> bool
   {
      return graph.getVertexDegree( vertexIdx ) > 1;
   };

   /***
    * Traverse vertices that satisfy the condition.
    */
   auto processVertex = [] __cuda_callable__( typename GraphType::VertexView vertex ) mutable
   {
      for( int i = 0; i < vertex.getDegree(); i++ )
         vertex.setEdge( i, ( vertex.getTargetIndex( i ) + 1 ) % 5, vertex.getEdgeWeight( i ) + 5 );
   };
   TNL::Graphs::forAllVerticesIf( graph, condition, processVertex );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forAllVerticesIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forAllVerticesIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     2:15      3:25  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     3:60  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     2:15      3:25  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     3:60  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 

forEdges() [1/6]

template<typename Graph, typename Array, typename Function>

void TNL::Graphs::forEdges	(	const Graph &	graph,
		const Array &	vertexIndexes,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over all edges of graph vertices with the given indexes and applies the specified lambda function. This function is for constant matrices.

See also: Overview of Graph Traversal Functions

Template Parameters

Graph	The type of the graph.
Array	The type of the array containing the indexes of the graph vertices to iterate over. This can be containers such as TNL::Containers::Array, TNL::Containers::ArrayView, TNL::Containers::Vector, or TNL::Containers::VectorView.
Function	The type of the lambda function to be applied to each edge.

Parameters

graph	The graph whose edges will be processed using the lambda function.
vertexIndexes	The array containing the indexes of the graph vertices to iterate over.
function	Lambda function to be applied to each edge. See Traversal Function (Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
forEdgesWithIndexesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Create an array of vertex indices to process.
    */
   TNL::Containers::Vector< int, Device > vertices( { 0, 2, 3 } );

   /***
    * Traverse edges only from the specified vertices.
    */
   auto modifyEdge = [] __cuda_callable__( int sourceIdx, int localIdx, int targetIdx, float weight ) mutable
   {
      targetIdx = ( targetIdx + 1 ) % 5;
      weight += 5;
   };
   TNL::Graphs::forEdges( graph, vertices, modifyEdge );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forEdgesWithIndexesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forEdgesWithIndexesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 

forEdges() [2/6]

template<typename Graph, typename Array, typename IndexBegin, typename IndexEnd, typename Function>

void TNL::Graphs::forEdges	(	const Graph &	graph,
		const Array &	vertexIndexes,
		IndexBegin	begin,
		IndexEnd	end,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over all edges of graph vertices with the given indexes and applies the specified lambda function. This function is for constant matrices.

See also: Overview of Graph Traversal Functions

Template Parameters

Graph	The type of the graph.
Array	The type of the array containing the indexes of the graph vertices to iterate over. This can be containers such as TNL::Containers::Array, TNL::Containers::ArrayView, TNL::Containers::Vector, or TNL::Containers::VectorView.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertex indexes whose edges will be processed using the lambda function.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertex indexes whose edges will be processed using the lambda function.
Function	The type of the lambda function to be applied to each edge.

Parameters

graph	The graph whose edges will be processed using the lambda function.
vertexIndexes	The array containing the indexes of the graph vertices to iterate over.
begin	The beginning of the interval [ begin, end ) of vertex indexes whose edges will be processed using the lambda function.
end	The end of the interval [ begin, end ) of vertex indexes whose edges will be processed using the lambda function.
function	Lambda function to be applied to each edge. See Traversal Function (Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
forEdgesWithIndexesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Create an array of vertex indices to process.
    */
   TNL::Containers::Vector< int, Device > vertices( { 0, 2, 3 } );

   /***
    * Traverse edges only from the specified vertices.
    */
   auto modifyEdge = [] __cuda_callable__( int sourceIdx, int localIdx, int targetIdx, float weight ) mutable
   {
      targetIdx = ( targetIdx + 1 ) % 5;
      weight += 5;
   };
   TNL::Graphs::forEdges( graph, vertices, modifyEdge );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forEdgesWithIndexesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forEdgesWithIndexesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 

forEdges() [3/6]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Function>

void TNL::Graphs::forEdges	(	const Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over all edges of constant graph in the given range of graph vertices and applies the specified lambda function.

See also: Overview of Graph Traversal Functions

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices whose edges we want to process using the lambda function.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices whose edges we want to process using the lambda function.
Function	The type of the lambda function to be applied to each edge.

Parameters

graph	The graph whose edges will be processed using the lambda function.
begin	The beginning of the interval [ begin, end ) of vertices whose edges will be processed using the lambda function.
end	The end of the interval [ begin, end ) of vertices whose edges will be processed using the lambda function.
function	Lambda function to be applied to each edge. See Traversal Function (Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void
forAllEdgesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Traverse edges in range [1, 4) and modify them.
    */
   auto modifyEdge = [] __cuda_callable__( int sourceIdx, int localIdx, int& targetIdx, float& weight ) mutable
   {
      targetIdx = ( targetIdx + 1 ) % 5;
      weight += 5;
   };
   TNL::Graphs::forEdges( graph, 1, 4, modifyEdge );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forAllEdgesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forAllEdgesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     4:65  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     4:65  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 

forEdges() [4/6]

template<typename Graph, typename Array, typename Function>

void TNL::Graphs::forEdges	(	Graph &	graph,
		const Array &	vertexIndexes,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over all edges of graph vertices with the given indexes and applies the specified lambda function.

See also: Overview of Graph Traversal Functions

Template Parameters

Graph	The type of the graph.
Array	The type of the array containing the indexes of the graph vertices to iterate over. This can be containers such as TNL::Containers::Array, TNL::Containers::ArrayView, TNL::Containers::Vector, or TNL::Containers::VectorView.
Function	The type of the lambda function to be applied to each edge.

Parameters

graph	The graph whose edges will be processed using the lambda function.
vertexIndexes	The array containing the indexes of the graph vertices to iterate over.
function	Lambda function to be applied to each edge. See Traversal Function (Non-Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
forEdgesWithIndexesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Create an array of vertex indices to process.
    */
   TNL::Containers::Vector< int, Device > vertices( { 0, 2, 3 } );

   /***
    * Traverse edges only from the specified vertices.
    */
   auto modifyEdge = [] __cuda_callable__( int sourceIdx, int localIdx, int targetIdx, float weight ) mutable
   {
      targetIdx = ( targetIdx + 1 ) % 5;
      weight += 5;
   };
   TNL::Graphs::forEdges( graph, vertices, modifyEdge );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forEdgesWithIndexesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forEdgesWithIndexesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 

forEdges() [5/6]

template<typename Graph, typename Array, typename IndexBegin, typename IndexEnd, typename Function>

void TNL::Graphs::forEdges	(	Graph &	graph,
		const Array &	vertexIndexes,
		IndexBegin	begin,
		IndexEnd	end,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over all edges of graph vertices with the given indexes and applies the specified lambda function.

See also: Overview of Graph Traversal Functions

Template Parameters

Graph	The type of the graph.
Array	The type of the array containing the indexes of the graph vertices to iterate over. This can be containers such as TNL::Containers::Array, TNL::Containers::ArrayView, TNL::Containers::Vector, or TNL::Containers::VectorView.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertex indexes whose edges will be processed using the lambda function.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertex indexes whose edges will be processed using the lambda function.
Function	The type of the lambda function to be applied to each edge.

Parameters

graph	The graph whose edges will be processed using the lambda function.
vertexIndexes	The array containing the indexes of the graph vertices to iterate over.
begin	The beginning of the interval [ begin, end ) of vertex indexes whose edges will be processed using the lambda function.
end	The end of the interval [ begin, end ) of vertex indexes whose edges will be processed using the lambda function.
function	Lambda function to be applied to each edge. See Traversal Function (Non-Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
forEdgesWithIndexesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Create an array of vertex indices to process.
    */
   TNL::Containers::Vector< int, Device > vertices( { 0, 2, 3 } );

   /***
    * Traverse edges only from the specified vertices.
    */
   auto modifyEdge = [] __cuda_callable__( int sourceIdx, int localIdx, int targetIdx, float weight ) mutable
   {
      targetIdx = ( targetIdx + 1 ) % 5;
      weight += 5;
   };
   TNL::Graphs::forEdges( graph, vertices, modifyEdge );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forEdgesWithIndexesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forEdgesWithIndexesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 

forEdges() [6/6]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Function>

void TNL::Graphs::forEdges	(	Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over all edges in the given range of graph vertices and applies the specified lambda function.

See also: Overview of Graph Traversal Functions

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices whose edges we want to process using the lambda function.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices whose edges we want to process using the lambda function.
Function	The type of the lambda function to be applied to each edge.

Parameters

graph	The graph whose edges will be processed using the lambda function.
begin	The beginning of the interval [ begin, end ) of vertices whose edges will be processed using the lambda function.
end	The end of the interval [ begin, end ) of vertices whose edges will be processed using the lambda function.
function	Lambda function to be applied to each edge. See Traversal Function (Non-Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void
forAllEdgesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Traverse edges in range [1, 4) and modify them.
    */
   auto modifyEdge = [] __cuda_callable__( int sourceIdx, int localIdx, int& targetIdx, float& weight ) mutable
   {
      targetIdx = ( targetIdx + 1 ) % 5;
      weight += 5;
   };
   TNL::Graphs::forEdges( graph, 1, 4, modifyEdge );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forAllEdgesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forAllEdgesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     4:65  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     4:65  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 

forEdgesIf() [1/2]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Condition, typename Function>

void TNL::Graphs::forEdgesIf	(	const Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Condition &&	condition,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over all edges in a given range of vertices based on a condition. This function is for constant matrices.

See also: Overview of Graph Traversal Functions

For each graph vertex, a condition lambda function is evaluated based on the vertex index. If the condition lambda function returns true, all edges of the vertex are traversed, and the specified lambda function is applied to each edge. If the condition lambda function returns false, the vertex is skipped.

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices whose edges will be processed using the lambda function.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices whose edges will be processed using the lambda function.
Condition	The type of the condition lambda function.
Function	The type of the lambda function to be applied to each edge.

Parameters

graph	The graph whose edges will be processed using the lambda function.
begin	The beginning of the interval [ begin, end ) of vertices whose edges will be processed using the lambda function.
end	The end of the interval [ begin, end ) of vertices whose edges will be processed using the lambda function.
condition	Lambda function to check vertex condition. See Condition Lambda.
function	Lambda function to be applied to each edge. See Traversal Function (Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void
forAllEdgesIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Define a condition: process only vertices with even indices.
    */
   auto condition = [] __cuda_callable__( int vertexIdx ) -> bool
   {
      return vertexIdx % 2 == 0;
   };

   /***
    * Traverse edges only from vertices that satisfy the condition.
    */
   auto modifyEdge = [] __cuda_callable__( int sourceIdx, int localIdx, int targetIdx, float weight ) mutable
   {
      targetIdx = ( targetIdx + 1 ) % 5;
      weight += 5;
   };
   TNL::Graphs::forAllEdgesIf( graph, condition, modifyEdge );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forAllEdgesIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forAllEdgesIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 

forEdgesIf() [2/2]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Condition, typename Function>

void TNL::Graphs::forEdgesIf	(	Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Condition &&	condition,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over all edges in a given range of vertices based on a condition.

See also: Overview of Graph Traversal Functions

For each graph vertex, a condition lambda function is evaluated based on the vertex index. If the condition lambda function returns true, all edges of the vertex are traversed, and the specified lambda function is applied to each edge. If the condition lambda function returns false, the vertex is skipped.

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices whose edges will be processed using the lambda function.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices whose edges will be processed using the lambda function.
Condition	The type of the condition lambda function.
Function	The type of the lambda function to be applied to each edge.

Parameters

graph	The graph whose edges will be processed using the lambda function.
begin	The beginning of the interval [ begin, end ) of vertices whose edges will be processed using the lambda function.
end	The end of the interval [ begin, end ) of vertices whose edges will be processed using the lambda function.
condition	Lambda function to check vertex condition. See Condition Lambda.
function	Lambda function to be applied to each edge. See Traversal Function (Non-Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void
forAllEdgesIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Define a condition: process only vertices with even indices.
    */
   auto condition = [] __cuda_callable__( int vertexIdx ) -> bool
   {
      return vertexIdx % 2 == 0;
   };

   /***
    * Traverse edges only from vertices that satisfy the condition.
    */
   auto modifyEdge = [] __cuda_callable__( int sourceIdx, int localIdx, int targetIdx, float weight ) mutable
   {
      targetIdx = ( targetIdx + 1 ) % 5;
      weight += 5;
   };
   TNL::Graphs::forAllEdgesIf( graph, condition, modifyEdge );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forAllEdgesIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forAllEdgesIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 

forVertices() [1/6]

template<typename Graph, typename Array, typename Function, typename T = std::enable_if_t< IsArrayType< Array >::value >>

void TNL::Graphs::forVertices	(	const Graph &	graph,
		const Array &	vertexIndexes,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over graph vertices with the given indexes and applies the specified lambda function to each vertex. This function is for constant matrices.

See also: Overview of Graph Traversal Functions

Template Parameters

Graph	The type of the graph.
Array	The type of the array containing the indexes of the graph vertices to iterate over. This can be containers such as TNL::Containers::Array, TNL::Containers::ArrayView, TNL::Containers::Vector, or TNL::Containers::VectorView.
Function	The type of the lambda function to be executed on each vertex.

Parameters

graph	The graph on which the lambda function will be applied.
vertexIndexes	The array containing the indexes of the graph vertices to iterate over.
function	Lambda function to be applied to each vertex. See Vertex Traversal Function (Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
forVerticesWithIndexesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Create an array of vertex indices.
    */
   TNL::Containers::Vector< int, Device > vertices( { 0, 2, 4 } );

   /***
    * Traverse only the specified vertices.
    */
   auto processVertex = [] __cuda_callable__( typename GraphType::VertexView vertex ) mutable
   {
      for( int i = 0; i < vertex.getDegree(); i++ )
         vertex.setEdge( i, ( vertex.getTargetIndex( i ) + 1 ) % 5, vertex.getEdgeWeight( i ) + 5 );
   };
   TNL::Graphs::forVertices( graph, vertices, processVertex );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forVerticesWithIndexesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forVerticesWithIndexesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     2:15      3:25  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     4:65  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     2:15      3:25  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     4:65  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 

forVertices() [2/6]

template<typename Graph, typename Array, typename IndexBegin, typename IndexEnd, typename Function, typename T = std::enable_if_t< IsArrayType< Array >::value && std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>

void TNL::Graphs::forVertices	(	const Graph &	graph,
		const Array &	vertexIndexes,
		IndexBegin	begin,
		IndexEnd	end,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over graph vertices with the given indexes and applies the specified lambda function to each vertex. This function is for constant matrices.

See also: Overview of Graph Traversal Functions

Template Parameters

Graph	The type of the graph.
Array	The type of the array containing the indexes of the graph vertices to iterate over. This can be containers such as TNL::Containers::Array, TNL::Containers::ArrayView, TNL::Containers::Vector, or TNL::Containers::VectorView.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices on which the lambda function will be applied.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices on which the lambda function will be applied.
Function	The type of the lambda function to be executed on each vertex.

Parameters

graph	The graph on which the lambda function will be applied.
vertexIndexes	The array containing the indexes of the graph vertices to iterate over.
begin	The beginning of the interval [ begin, end ) of vertex indexes whose corresponding vertices will be processed using the lambda function.
end	The end of the interval [ begin, end ) of vertex indexes whose corresponding vertices will be processed using the lambda function.
function	Lambda function to be applied to each vertex. See Vertex Traversal Function (Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
forVerticesWithIndexesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Create an array of vertex indices.
    */
   TNL::Containers::Vector< int, Device > vertices( { 0, 2, 4 } );

   /***
    * Traverse only the specified vertices.
    */
   auto processVertex = [] __cuda_callable__( typename GraphType::VertexView vertex ) mutable
   {
      for( int i = 0; i < vertex.getDegree(); i++ )
         vertex.setEdge( i, ( vertex.getTargetIndex( i ) + 1 ) % 5, vertex.getEdgeWeight( i ) + 5 );
   };
   TNL::Graphs::forVertices( graph, vertices, processVertex );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forVerticesWithIndexesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forVerticesWithIndexesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     2:15      3:25  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     4:65  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     2:15      3:25  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     4:65  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 

forVertices() [3/6]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Function, typename T = std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>

void TNL::Graphs::forVertices	(	const Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over graph vertices within the specified range of vertex indexes and applies the given lambda function to each vertex. This function is for constant matrices.

See also: Overview of Graph Traversal Functions

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of graph vertices on which the lambda function will be applied.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of graph vertices on which the lambda function will be applied.
Function	The type of the lambda function to be executed on each vertex.

Parameters

graph	The graph on which the lambda function will be applied.
begin	The beginning of the interval [ begin, end ) of graph vertices that will be processed using the lambda function.
end	The end of the interval [ begin, end ) of graph vertices that will be processed using the lambda function.
function	Lambda function to be applied to each vertex. See Vertex Traversal Function (Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void
forVerticesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Traverse vertices in range [1, 4) and modify their edges.
    */
   auto processVertex = [] __cuda_callable__( typename GraphType::VertexView vertex ) mutable
   {
      for( int i = 0; i < vertex.getDegree(); i++ )
         vertex.setEdge( i, ( vertex.getTargetIndex( i ) + 1 ) % 5, vertex.getEdgeWeight( i ) + 5 );
   };
   TNL::Graphs::forVertices( graph, 1, 4, processVertex );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forVerticesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forVerticesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     4:65  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     4:65  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 

forVertices() [4/6]

template<typename Graph, typename Array, typename Function, typename T = std::enable_if_t< IsArrayType< Array >::value >>

void TNL::Graphs::forVertices	(	Graph &	graph,
		const Array &	vertexIndexes,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over graph vertices with the given indexes and applies the specified lambda function to each vertex.

See also: Overview of Graph Traversal Functions

Template Parameters

Graph	The type of the graph.
Array	The type of the array containing the indexes of the graph vertices to iterate over. This can be containers such as TNL::Containers::Array, TNL::Containers::ArrayView, TNL::Containers::Vector, or TNL::Containers::VectorView.
Function	The type of the lambda function to be executed on each vertex.

Parameters

graph	The graph on which the lambda function will be applied.
vertexIndexes	The array containing the indexes of the graph vertices to iterate over.
function	Lambda function to be applied to each vertex. See Vertex Traversal Function (Non-Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
forVerticesWithIndexesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Create an array of vertex indices.
    */
   TNL::Containers::Vector< int, Device > vertices( { 0, 2, 4 } );

   /***
    * Traverse only the specified vertices.
    */
   auto processVertex = [] __cuda_callable__( typename GraphType::VertexView vertex ) mutable
   {
      for( int i = 0; i < vertex.getDegree(); i++ )
         vertex.setEdge( i, ( vertex.getTargetIndex( i ) + 1 ) % 5, vertex.getEdgeWeight( i ) + 5 );
   };
   TNL::Graphs::forVertices( graph, vertices, processVertex );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forVerticesWithIndexesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forVerticesWithIndexesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     2:15      3:25  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     4:65  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     2:15      3:25  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     4:65  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 

forVertices() [5/6]

template<typename Graph, typename Array, typename IndexBegin, typename IndexEnd, typename Function, typename T = std::enable_if_t< IsArrayType< Array >::value && std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>

void TNL::Graphs::forVertices	(	Graph &	graph,
		const Array &	vertexIndexes,
		IndexBegin	begin,
		IndexEnd	end,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over graph vertices with the given indexes and applies the specified lambda function to each vertex.

See also: Overview of Graph Traversal Functions

Template Parameters

Graph	The type of the graph.
Array	The type of the array containing the indexes of the graph vertices to iterate over. This can be containers such as TNL::Containers::Array, TNL::Containers::ArrayView, TNL::Containers::Vector, or TNL::Containers::VectorView.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices on which the lambda function will be applied.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices on which the lambda function will be applied.
Function	The type of the lambda function to be executed on each vertex.

Parameters

graph	The graph on which the lambda function will be applied.
vertexIndexes	The array containing the indexes of the graph vertices to iterate over.
begin	The beginning of the interval [ begin, end ) of vertex indexes whose corresponding vertices will be processed using the lambda function.
end	The end of the interval [ begin, end ) of vertex indexes whose corresponding vertices will be processed using the lambda function.
function	Lambda function to be applied to each vertex. See Vertex Traversal Function (Non-Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
forVerticesWithIndexesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Create an array of vertex indices.
    */
   TNL::Containers::Vector< int, Device > vertices( { 0, 2, 4 } );

   /***
    * Traverse only the specified vertices.
    */
   auto processVertex = [] __cuda_callable__( typename GraphType::VertexView vertex ) mutable
   {
      for( int i = 0; i < vertex.getDegree(); i++ )
         vertex.setEdge( i, ( vertex.getTargetIndex( i ) + 1 ) % 5, vertex.getEdgeWeight( i ) + 5 );
   };
   TNL::Graphs::forVertices( graph, vertices, processVertex );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forVerticesWithIndexesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forVerticesWithIndexesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     2:15      3:25  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     4:65  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     2:15      3:25  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     4:65  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 

forVertices() [6/6]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Function, typename T = std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>

void TNL::Graphs::forVertices	(	Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over graph vertices within the specified range of vertex indexes and applies the given lambda function to each vertex.

See also: Overview of Graph Traversal Functions

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of graph vertices on which the lambda function will be applied.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of graph vertices on which the lambda function will be applied.
Function	The type of the lambda function to be executed on each vertex.

Parameters

graph	The graph on which the lambda function will be applied.
begin	The beginning of the interval [ begin, end ) of graph vertices that will be processed using the lambda function.
end	The end of the interval [ begin, end ) of graph vertices that will be processed using the lambda function.
function	Lambda function to be applied to each vertex. See Vertex Traversal Function (Non-Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void
forVerticesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Traverse vertices in range [1, 4) and modify their edges.
    */
   auto processVertex = [] __cuda_callable__( typename GraphType::VertexView vertex ) mutable
   {
      for( int i = 0; i < vertex.getDegree(); i++ )
         vertex.setEdge( i, ( vertex.getTargetIndex( i ) + 1 ) % 5, vertex.getEdgeWeight( i ) + 5 );
   };
   TNL::Graphs::forVertices( graph, 1, 4, processVertex );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forVerticesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forVerticesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     4:65  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     4:65  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 

forVerticesIf() [1/2]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename VertexCondition, typename Function, typename T = std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>

void TNL::Graphs::forVerticesIf	(	const Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		VertexCondition &&	vertexCondition,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over vertices within the given range of vertex indexes, applying a condition to determine whether each vertex should be processed. This function is for constant matrices.

See also: Overview of Graph Traversal Functions

For each vertex, a condition lambda function is evaluated based on the vertex index. If the condition lambda function returns true, the specified lambda function is executed for the vertex. If the condition lambda function returns false, the vertex is skipped.

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices on which the lambda function will be applied.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices on which the lambda function will be applied.
VertexCondition	The type of the condition lambda function.
Function	The type of the lambda function to be executed on each vertex.

Parameters

graph	The graph on which the lambda function will be applied.
begin	The beginning of the interval [ begin, end ) of vertex indexes whose corresponding vertices will be processed using the lambda function.
end	The end of the interval [ begin, end ) of vertex indexes whose corresponding vertices will be processed using the lambda function.
vertexCondition	Lambda function to check vertex condition. See Condition Lambda.
function	Lambda function to be applied to each vertex. See Vertex Traversal Function (Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void
forAllVerticesIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                        { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                        { 2, 3, 60.0 },
          { 3, 0, 70.0 },                               { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Define a condition: process only vertices with more than one edge.
    */
   auto condition = [ = ] __cuda_callable__( int vertexIdx ) -> bool
   {
      return graph.getVertexDegree( vertexIdx ) > 1;
   };

   /***
    * Traverse vertices that satisfy the condition.
    */
   auto processVertex = [] __cuda_callable__( typename GraphType::VertexView vertex ) mutable
   {
      for( int i = 0; i < vertex.getDegree(); i++ )
         vertex.setEdge( i, ( vertex.getTargetIndex( i ) + 1 ) % 5, vertex.getEdgeWeight( i ) + 5 );
   };
   TNL::Graphs::forAllVerticesIf( graph, condition, processVertex );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forAllVerticesIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forAllVerticesIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     2:15      3:25  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     3:60  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     2:15      3:25  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     3:60  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 

forVerticesIf() [2/2]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename VertexCondition, typename Function, typename T = std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>

void TNL::Graphs::forVerticesIf	(	Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		VertexCondition &&	vertexCondition,
		Function &&	function,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Iterates in parallel over vertices within the given range of vertex indexes, applying a condition to determine whether each vertex should be processed.

See also: Overview of Graph Traversal Functions

For each vertex, a condition lambda function is evaluated based on the vertex index. If the condition lambda function returns true, the specified lambda function is executed for the vertex. If the condition lambda function returns false, the vertex is skipped.

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices on which the lambda function will be applied.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices on which the lambda function will be applied.
VertexCondition	The type of the condition lambda function.
Function	The type of the lambda function to be executed on each vertex.

Parameters

graph	The graph on which the lambda function will be applied.
begin	The beginning of the interval [ begin, end ) of vertex indexes whose corresponding vertices will be processed using the lambda function.
end	The end of the interval [ begin, end ) of vertex indexes whose corresponding vertices will be processed using the lambda function.
vertexCondition	Lambda function to check vertex condition. See Condition Lambda.
function	Lambda function to be applied to each vertex. See Vertex Traversal Function (Non-Const Graph).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/traverse.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
 
template< typename Device >
void
forAllVerticesIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                        { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                        { 2, 3, 60.0 },
          { 3, 0, 70.0 },                               { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Define a condition: process only vertices with more than one edge.
    */
   auto condition = [ = ] __cuda_callable__( int vertexIdx ) -> bool
   {
      return graph.getVertexDegree( vertexIdx ) > 1;
   };

   /***
    * Traverse vertices that satisfy the condition.
    */
   auto processVertex = [] __cuda_callable__( typename GraphType::VertexView vertex ) mutable
   {
      for( int i = 0; i < vertex.getDegree(); i++ )
         vertex.setEdge( i, ( vertex.getTargetIndex( i ) + 1 ) % 5, vertex.getEdgeWeight( i ) + 5 );
   };
   TNL::Graphs::forAllVerticesIf( graph, condition, processVertex );
 
   /***
    * Print the modified graph.
    */
   std::cout << "Modified graph:\n" << graph << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   forAllVerticesIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   forAllVerticesIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     2:15      3:25  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     3:60  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Modified graph:
Row: 0 ->     2:15      3:25  
Row: 1 ->     3:35      4:45      0:55  
Row: 2 ->     3:60  
Row: 3 ->     1:75      0:85  
Row: 4 -> 
 

operator<<()

template<typename Real, typename Index>

std::ostream & TNL::Graphs::operator<<	(	std::ostream &	os,
		const Edge< Real, Index > &	edge )

Stream output operator for Edge.

Outputs the edge in the format: (source, target, weight)

Template Parameters

Real	Type for the edge weight.
Index	Type for vertex indices.

Parameters

os	Output stream.
edge	The edge to output.

Returns

Reference to the output stream.

reduceAllVertices() [1/4]

template<typename Graph, typename Fetch, typename Reduction, typename Store, typename FetchValue>

void TNL::Graphs::reduceAllVertices	(	const Graph &	graph,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		const FetchValue &	identity,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over all vertices (const version).

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.
FetchValue	The type returned by the Fetch lambda function.

Parameters

graph	The graph on which the reduction will be performed.
fetch	Lambda function for fetching data. See For Const Graphs.
reduction	Lambda function for reduction operation. See Basic Reduction (Without Arguments).
store	Lambda function for storing results. See Basic Store (Vertex Index Only).
identity	The initial value for the reduction operation.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';
 
   /***
    * Compute maximum edge weight for vertices in range [1, 4).
    */
   TNL::Containers::Vector< float, Device > vertexMaxWeights( 5, -1 );
   auto vertexMaxWeights_view = vertexMaxWeights.getView();

   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };

   auto store = [ = ] __cuda_callable__( int vertexIdx, const float& maxWeight ) mutable
   {
      vertexMaxWeights_view[ vertexIdx ] = maxWeight;
   };

   TNL::Graphs::reduceVertices( graph, 1, 4, fetch, TNL::Max{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Maximum edge weight for vertices 1-3:" << vertexMaxWeights << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Maximum edge weight for vertices 1-3:[ -1, 50, 60, 80, -1 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Maximum edge weight for vertices 1-3:[ -1, 50, 60, 80, -1 ]

reduceAllVertices() [2/4]

template<typename Graph, typename Fetch, typename Reduction, typename Store>

void TNL::Graphs::reduceAllVertices	(	const Graph &	graph,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over all vertices with automatic identity deduction (const version).

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.

Parameters

graph	The graph on which the reduction will be performed.
fetch	Lambda function for fetching data. See For Const Graphs.
reduction	Function object for reduction operation. See Reduction Function Objects.
store	Lambda function for storing results. See Basic Store (Vertex Index Only).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';
 
   /***
    * Compute maximum edge weight for vertices in range [1, 4).
    */
   TNL::Containers::Vector< float, Device > vertexMaxWeights( 5, -1 );
   auto vertexMaxWeights_view = vertexMaxWeights.getView();

   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };

   auto store = [ = ] __cuda_callable__( int vertexIdx, const float& maxWeight ) mutable
   {
      vertexMaxWeights_view[ vertexIdx ] = maxWeight;
   };

   TNL::Graphs::reduceVertices( graph, 1, 4, fetch, TNL::Max{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Maximum edge weight for vertices 1-3:" << vertexMaxWeights << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Maximum edge weight for vertices 1-3:[ -1, 50, 60, 80, -1 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Maximum edge weight for vertices 1-3:[ -1, 50, 60, 80, -1 ]

reduceAllVertices() [3/4]

template<typename Graph, typename Fetch, typename Reduction, typename Store, typename FetchValue>

void TNL::Graphs::reduceAllVertices	(	Graph &	graph,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		const FetchValue &	identity,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over all vertices.

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.
FetchValue	The type returned by the Fetch lambda function.

Parameters

graph	The graph on which the reduction will be performed.
fetch	Lambda function for fetching data. See For Non-Const Graphs.
reduction	Lambda function for reduction operation. See Basic Reduction (Without Arguments).
store	Lambda function for storing results. See Basic Store (Vertex Index Only).
identity	The initial value for the reduction operation.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';
 
   /***
    * Compute maximum edge weight for vertices in range [1, 4).
    */
   TNL::Containers::Vector< float, Device > vertexMaxWeights( 5, -1 );
   auto vertexMaxWeights_view = vertexMaxWeights.getView();

   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };

   auto store = [ = ] __cuda_callable__( int vertexIdx, const float& maxWeight ) mutable
   {
      vertexMaxWeights_view[ vertexIdx ] = maxWeight;
   };

   TNL::Graphs::reduceVertices( graph, 1, 4, fetch, TNL::Max{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Maximum edge weight for vertices 1-3:" << vertexMaxWeights << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Maximum edge weight for vertices 1-3:[ -1, 50, 60, 80, -1 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Maximum edge weight for vertices 1-3:[ -1, 50, 60, 80, -1 ]

reduceAllVertices() [4/4]

template<typename Graph, typename Fetch, typename Reduction, typename Store>

void TNL::Graphs::reduceAllVertices	(	Graph &	graph,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over all vertices with automatic identity deduction.

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.

Parameters

graph	The graph on which the reduction will be performed.
fetch	Lambda function for fetching data. See For Non-Const Graphs.
reduction	Function object for reduction operation. See Reduction Function Objects.
store	Lambda function for storing results. See Basic Store (Vertex Index Only).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';
 
   /***
    * Compute maximum edge weight for vertices in range [1, 4).
    */
   TNL::Containers::Vector< float, Device > vertexMaxWeights( 5, -1 );
   auto vertexMaxWeights_view = vertexMaxWeights.getView();

   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };

   auto store = [ = ] __cuda_callable__( int vertexIdx, const float& maxWeight ) mutable
   {
      vertexMaxWeights_view[ vertexIdx ] = maxWeight;
   };

   TNL::Graphs::reduceVertices( graph, 1, 4, fetch, TNL::Max{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Maximum edge weight for vertices 1-3:" << vertexMaxWeights << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Maximum edge weight for vertices 1-3:[ -1, 50, 60, 80, -1 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Maximum edge weight for vertices 1-3:[ -1, 50, 60, 80, -1 ]

reduceAllVerticesIf() [1/4]

template<typename Graph, typename Condition, typename Fetch, typename Reduction, typename Store, typename FetchValue>

Graph::IndexType TNL::Graphs::reduceAllVerticesIf	(	const Graph &	graph,
		Condition &&	condition,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		const FetchValue &	identity,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over all vertices based on a condition (const version).

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Condition	The type of the lambda function used for the condition check.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.
FetchValue	The type returned by the Fetch lambda function.

Parameters

graph	The graph on which the reduction will be performed.
condition	Lambda function for condition check. See Condition Check.
fetch	Lambda function for fetching data. See For Const Graphs.
reduction	Lambda function for reduction operation. See Basic Reduction (Without Arguments).
store	Lambda function for storing results. See Basic Store (Vertex Index Only).
identity	The initial value for the reduction operation.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Returns

The number of processed vertices, i.e. vertices for which the condition was true.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Compute minimum edge weight for vertices in range [1, 4) with degree >= 2.
    */
   TNL::Containers::Vector< float, Device > vertexMinWeights( 5, -1 );
   TNL::Containers::Vector< float, Device > compressedVertexMinWeights( 5 );
   auto vertexMinWeights_view = vertexMinWeights.getView();
   auto compressedVertexMinWeights_view = compressedVertexMinWeights.getView();
 
   auto condition = [ = ] __cuda_callable__( int vertexIdx ) -> bool
   {
      return graph.getVertexDegree( vertexIdx ) >= 2;
   };
 
   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };
 
   auto store = [ = ] __cuda_callable__( int indexOfVertexIdx, int vertexIdx, const float& minWeight ) mutable
   {
      compressedVertexMinWeights_view[ indexOfVertexIdx ] = minWeight;
      vertexMinWeights_view[ vertexIdx ] = minWeight;
   };
 
   int reducedVertexCount = TNL::Graphs::reduceVerticesIf( graph, 1, 4, condition, fetch, TNL::Min{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Number of reduced vertices: " << reducedVertexCount << '\n';
   std::cout << "Minimum edge weight for vertices 1-3 with degree >= 2:" << vertexMinWeights << '\n';
   std::cout << "Compressed minimum weights:" << compressedVertexMinWeights.getView( 0, reducedVertexCount ) << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of reduced vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Compressed minimum weights:[ 30, 70 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of reduced vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Compressed minimum weights:[ 30, 70 ]

reduceAllVerticesIf() [2/4]

template<typename Graph, typename Condition, typename Fetch, typename Reduction, typename Store>

Graph::IndexType TNL::Graphs::reduceAllVerticesIf	(	const Graph &	graph,
		Condition &&	condition,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over all vertices based on a condition with automatic identity deduction (const version).

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Condition	The type of the lambda function used for the condition check.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.

Parameters

graph	The graph on which the reduction will be performed.
condition	Lambda function for condition check. See Condition Check.
fetch	Lambda function for fetching data. See For Const Graphs.
reduction	Function object for reduction operation. See Reduction Function Objects.
store	Lambda function for storing results. See Basic Store (Vertex Index Only).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Returns

The number of processed vertices, i.e. vertices for which the condition was true.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Compute minimum edge weight for vertices in range [1, 4) with degree >= 2.
    */
   TNL::Containers::Vector< float, Device > vertexMinWeights( 5, -1 );
   TNL::Containers::Vector< float, Device > compressedVertexMinWeights( 5 );
   auto vertexMinWeights_view = vertexMinWeights.getView();
   auto compressedVertexMinWeights_view = compressedVertexMinWeights.getView();
 
   auto condition = [ = ] __cuda_callable__( int vertexIdx ) -> bool
   {
      return graph.getVertexDegree( vertexIdx ) >= 2;
   };
 
   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };
 
   auto store = [ = ] __cuda_callable__( int indexOfVertexIdx, int vertexIdx, const float& minWeight ) mutable
   {
      compressedVertexMinWeights_view[ indexOfVertexIdx ] = minWeight;
      vertexMinWeights_view[ vertexIdx ] = minWeight;
   };
 
   int reducedVertexCount = TNL::Graphs::reduceVerticesIf( graph, 1, 4, condition, fetch, TNL::Min{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Number of reduced vertices: " << reducedVertexCount << '\n';
   std::cout << "Minimum edge weight for vertices 1-3 with degree >= 2:" << vertexMinWeights << '\n';
   std::cout << "Compressed minimum weights:" << compressedVertexMinWeights.getView( 0, reducedVertexCount ) << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of reduced vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Compressed minimum weights:[ 30, 70 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of reduced vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Compressed minimum weights:[ 30, 70 ]

reduceAllVerticesIf() [3/4]

template<typename Graph, typename Condition, typename Fetch, typename Reduction, typename Store, typename FetchValue>

Graph::IndexType TNL::Graphs::reduceAllVerticesIf	(	Graph &	graph,
		Condition &&	condition,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		const FetchValue &	identity,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over all vertices based on a condition.

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Condition	The type of the lambda function used for the condition check.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.
FetchValue	The type returned by the Fetch lambda function.

Parameters

graph	The graph on which the reduction will be performed.
condition	Lambda function for condition check. See Condition Check.
fetch	Lambda function for fetching data. See For Non-Const Graphs.
reduction	Lambda function for reduction operation. See Basic Reduction (Without Arguments).
store	Lambda function for storing results. See Basic Store (Vertex Index Only).
identity	The initial value for the reduction operation.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Returns

The number of processed vertices, i.e. vertices for which the condition was true.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Compute minimum edge weight for vertices in range [1, 4) with degree >= 2.
    */
   TNL::Containers::Vector< float, Device > vertexMinWeights( 5, -1 );
   TNL::Containers::Vector< float, Device > compressedVertexMinWeights( 5 );
   auto vertexMinWeights_view = vertexMinWeights.getView();
   auto compressedVertexMinWeights_view = compressedVertexMinWeights.getView();
 
   auto condition = [ = ] __cuda_callable__( int vertexIdx ) -> bool
   {
      return graph.getVertexDegree( vertexIdx ) >= 2;
   };
 
   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };
 
   auto store = [ = ] __cuda_callable__( int indexOfVertexIdx, int vertexIdx, const float& minWeight ) mutable
   {
      compressedVertexMinWeights_view[ indexOfVertexIdx ] = minWeight;
      vertexMinWeights_view[ vertexIdx ] = minWeight;
   };
 
   int reducedVertexCount = TNL::Graphs::reduceVerticesIf( graph, 1, 4, condition, fetch, TNL::Min{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Number of reduced vertices: " << reducedVertexCount << '\n';
   std::cout << "Minimum edge weight for vertices 1-3 with degree >= 2:" << vertexMinWeights << '\n';
   std::cout << "Compressed minimum weights:" << compressedVertexMinWeights.getView( 0, reducedVertexCount ) << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of reduced vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Compressed minimum weights:[ 30, 70 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of reduced vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Compressed minimum weights:[ 30, 70 ]

reduceAllVerticesIf() [4/4]

template<typename Graph, typename Condition, typename Fetch, typename Reduction, typename Store>

Graph::IndexType TNL::Graphs::reduceAllVerticesIf	(	Graph &	graph,
		Condition &&	condition,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over all vertices based on a condition with automatic identity deduction.

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Condition	The type of the lambda function used for the condition check.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.

Parameters

graph	The graph on which the reduction will be performed.
condition	Lambda function for condition check. See Condition Check.
fetch	Lambda function for fetching data. See For Non-Const Graphs.
reduction	Function object for reduction operation. See Reduction Function Objects.
store	Lambda function for storing results. See Basic Store (Vertex Index Only).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Returns

The number of processed vertices, i.e. vertices for which the condition was true.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Compute minimum edge weight for vertices in range [1, 4) with degree >= 2.
    */
   TNL::Containers::Vector< float, Device > vertexMinWeights( 5, -1 );
   TNL::Containers::Vector< float, Device > compressedVertexMinWeights( 5 );
   auto vertexMinWeights_view = vertexMinWeights.getView();
   auto compressedVertexMinWeights_view = compressedVertexMinWeights.getView();
 
   auto condition = [ = ] __cuda_callable__( int vertexIdx ) -> bool
   {
      return graph.getVertexDegree( vertexIdx ) >= 2;
   };
 
   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };
 
   auto store = [ = ] __cuda_callable__( int indexOfVertexIdx, int vertexIdx, const float& minWeight ) mutable
   {
      compressedVertexMinWeights_view[ indexOfVertexIdx ] = minWeight;
      vertexMinWeights_view[ vertexIdx ] = minWeight;
   };
 
   int reducedVertexCount = TNL::Graphs::reduceVerticesIf( graph, 1, 4, condition, fetch, TNL::Min{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Number of reduced vertices: " << reducedVertexCount << '\n';
   std::cout << "Minimum edge weight for vertices 1-3 with degree >= 2:" << vertexMinWeights << '\n';
   std::cout << "Compressed minimum weights:" << compressedVertexMinWeights.getView( 0, reducedVertexCount ) << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of reduced vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Compressed minimum weights:[ 30, 70 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of reduced vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Compressed minimum weights:[ 30, 70 ]

reduceAllVerticesWithArgument() [1/4]

template<typename Graph, typename Fetch, typename Reduction, typename Store, typename FetchValue>

void TNL::Graphs::reduceAllVerticesWithArgument	(	const Graph &	graph,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		const FetchValue &	identity,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over all vertices while returning also the position of the edge of interest (const version).

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.
FetchValue	The type returned by the Fetch lambda function.

Parameters

graph	The graph on which the reduction will be performed.
fetch	Lambda function for fetching data. See For Const Graphs.
reduction	Lambda function for reduction with argument tracking. See Reduction With Argument (Position Tracking).
store	Lambda function for storing results with position tracking. See Store With Argument (Position Tracking).
identity	The initial value for the reduction operation.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesWithArgumentExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';
 
   /***
    * Find minimum edge weight and target vertex for vertices in range [1, 4).
    */
   TNL::Containers::Vector< float, Device > minWeights( 5, -1 );
   TNL::Containers::Vector< int, Device > minTargets( 5, -1 );
   auto minWeights_view = minWeights.getView();
   auto minTargets_view = minTargets.getView();

   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };

   auto store = [ = ] __cuda_callable__( int vertexIdx, int localIdx, int targetIdx, float result, bool isolatedVertex ) mutable
   {
      minWeights_view[ vertexIdx ] = result;
      if( ! isolatedVertex )
         minTargets_view[ vertexIdx ] = targetIdx;
   };

   TNL::Graphs::reduceVerticesWithArgument( graph, 1, 5, fetch, TNL::MinWithArg{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Minimum edge weight for vertices 1-4:" << minWeights << '\n';
   std::cout << "Target vertex for minimum edge:" << minTargets << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesWithArgumentExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesWithArgumentExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Minimum edge weight for vertices 1-4:[ -1, 30, 60, 70, 3.40282e+38 ]
Target vertex for minimum edge:[ -1, 2, 3, 0, -1 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Minimum edge weight for vertices 1-4:[ -1, 30, 60, 70, 3.40282e+38 ]
Target vertex for minimum edge:[ -1, 2, 3, 0, -1 ]

reduceAllVerticesWithArgument() [2/4]

template<typename Graph, typename Fetch, typename Reduction, typename Store>

void TNL::Graphs::reduceAllVerticesWithArgument	(	const Graph &	graph,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over all vertices while returning also the position of the edge of interest with automatic identity deduction (const version).

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.

Parameters

graph	The graph on which the reduction will be performed.
fetch	Lambda function for fetching data. See For Const Graphs.
reduction	Function object for reduction with argument tracking. See Reduction Function Objects.
store	Lambda function for storing results with position tracking. See Store With Argument (Position Tracking).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesWithArgumentExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';
 
   /***
    * Find minimum edge weight and target vertex for vertices in range [1, 4).
    */
   TNL::Containers::Vector< float, Device > minWeights( 5, -1 );
   TNL::Containers::Vector< int, Device > minTargets( 5, -1 );
   auto minWeights_view = minWeights.getView();
   auto minTargets_view = minTargets.getView();

   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };

   auto store = [ = ] __cuda_callable__( int vertexIdx, int localIdx, int targetIdx, float result, bool isolatedVertex ) mutable
   {
      minWeights_view[ vertexIdx ] = result;
      if( ! isolatedVertex )
         minTargets_view[ vertexIdx ] = targetIdx;
   };

   TNL::Graphs::reduceVerticesWithArgument( graph, 1, 5, fetch, TNL::MinWithArg{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Minimum edge weight for vertices 1-4:" << minWeights << '\n';
   std::cout << "Target vertex for minimum edge:" << minTargets << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesWithArgumentExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesWithArgumentExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Minimum edge weight for vertices 1-4:[ -1, 30, 60, 70, 3.40282e+38 ]
Target vertex for minimum edge:[ -1, 2, 3, 0, -1 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Minimum edge weight for vertices 1-4:[ -1, 30, 60, 70, 3.40282e+38 ]
Target vertex for minimum edge:[ -1, 2, 3, 0, -1 ]

reduceAllVerticesWithArgument() [3/4]

template<typename Graph, typename Fetch, typename Reduction, typename Store, typename FetchValue>

void TNL::Graphs::reduceAllVerticesWithArgument	(	Graph &	graph,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		const FetchValue &	identity,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over all vertices while returning also the position of the edge of interest.

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.
FetchValue	The type returned by the Fetch lambda function.

Parameters

graph	The graph on which the reduction will be performed.
fetch	Lambda function for fetching data. See For Non-Const Graphs.
reduction	Lambda function for reduction with argument tracking. See Reduction With Argument (Position Tracking).
store	Lambda function for storing results with position tracking. See Store With Argument (Position Tracking).
identity	The initial value for the reduction operation.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesWithArgumentExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';
 
   /***
    * Find minimum edge weight and target vertex for vertices in range [1, 4).
    */
   TNL::Containers::Vector< float, Device > minWeights( 5, -1 );
   TNL::Containers::Vector< int, Device > minTargets( 5, -1 );
   auto minWeights_view = minWeights.getView();
   auto minTargets_view = minTargets.getView();

   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };

   auto store = [ = ] __cuda_callable__( int vertexIdx, int localIdx, int targetIdx, float result, bool isolatedVertex ) mutable
   {
      minWeights_view[ vertexIdx ] = result;
      if( ! isolatedVertex )
         minTargets_view[ vertexIdx ] = targetIdx;
   };

   TNL::Graphs::reduceVerticesWithArgument( graph, 1, 5, fetch, TNL::MinWithArg{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Minimum edge weight for vertices 1-4:" << minWeights << '\n';
   std::cout << "Target vertex for minimum edge:" << minTargets << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesWithArgumentExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesWithArgumentExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Minimum edge weight for vertices 1-4:[ -1, 30, 60, 70, 3.40282e+38 ]
Target vertex for minimum edge:[ -1, 2, 3, 0, -1 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Minimum edge weight for vertices 1-4:[ -1, 30, 60, 70, 3.40282e+38 ]
Target vertex for minimum edge:[ -1, 2, 3, 0, -1 ]

reduceAllVerticesWithArgument() [4/4]

template<typename Graph, typename Fetch, typename Reduction, typename Store>

void TNL::Graphs::reduceAllVerticesWithArgument	(	Graph &	graph,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over all vertices while returning also the position of the edge of interest with automatic identity deduction.

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.

Parameters

graph	The graph on which the reduction will be performed.
fetch	Lambda function for fetching data. See For Non-Const Graphs.
reduction	Function object for reduction with argument tracking. See Reduction Function Objects.
store	Lambda function for storing results with position tracking. See Store With Argument (Position Tracking).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesWithArgumentExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';
 
   /***
    * Find minimum edge weight and target vertex for vertices in range [1, 4).
    */
   TNL::Containers::Vector< float, Device > minWeights( 5, -1 );
   TNL::Containers::Vector< int, Device > minTargets( 5, -1 );
   auto minWeights_view = minWeights.getView();
   auto minTargets_view = minTargets.getView();

   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };

   auto store = [ = ] __cuda_callable__( int vertexIdx, int localIdx, int targetIdx, float result, bool isolatedVertex ) mutable
   {
      minWeights_view[ vertexIdx ] = result;
      if( ! isolatedVertex )
         minTargets_view[ vertexIdx ] = targetIdx;
   };

   TNL::Graphs::reduceVerticesWithArgument( graph, 1, 5, fetch, TNL::MinWithArg{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Minimum edge weight for vertices 1-4:" << minWeights << '\n';
   std::cout << "Target vertex for minimum edge:" << minTargets << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesWithArgumentExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesWithArgumentExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Minimum edge weight for vertices 1-4:[ -1, 30, 60, 70, 3.40282e+38 ]
Target vertex for minimum edge:[ -1, 2, 3, 0, -1 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Minimum edge weight for vertices 1-4:[ -1, 30, 60, 70, 3.40282e+38 ]
Target vertex for minimum edge:[ -1, 2, 3, 0, -1 ]

reduceAllVerticesWithArgumentIf() [1/4]

template<typename Graph, typename Condition, typename Fetch, typename Reduction, typename Store, typename FetchValue = decltype( std::declval< Fetch >()( 0, 0, std::declval< typename Graph::RealType >() ) )>

Graph::IndexType TNL::Graphs::reduceAllVerticesWithArgumentIf	(	const Graph &	graph,
		Condition &&	condition,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		const FetchValue &	identity,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over all vertices based on a condition while returning also the position of the edge of interest (const version).

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Condition	The type of the lambda function used for the condition check.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.
FetchValue	The type returned by the Fetch lambda function.

Parameters

graph	The graph on which the reduction will be performed.
condition	Lambda function for vertex condition checking. See Condition Check.
fetch	Lambda function for fetching data. See For Const Graphs.
reduction	Function object for reduction with argument tracking. See Reduction Function Objects.
store	Lambda function for storing results with position tracking. See Store With Argument (Position Tracking).
identity	The identity edge for the reduction operation.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Returns

The number of processed vertices, i.e. vertices for which the condition was true.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesWithArgumentIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Find minimum edge weight and target vertex for vertices in range [1, 4) with degree >= 2.
    */
   TNL::Containers::Vector< float, Device > vertexMinWeights( 5, -1 );
   TNL::Containers::Vector< float, Device > compressedVertexMinWeights( 5 );
   TNL::Containers::Vector< int, Device > vertexMinTargets( 5, -1 );
   TNL::Containers::Vector< int, Device > compressedVertexMinTargets( 5 );
   auto vertexMinWeights_view = vertexMinWeights.getView();
   auto compressedVertexMinWeights_view = compressedVertexMinWeights.getView();
   auto vertexMinTargets_view = vertexMinTargets.getView();
   auto compressedVertexMinTargets_view = compressedVertexMinTargets.getView();
 
   auto condition = [ = ] __cuda_callable__( int vertexIdx ) -> bool
   {
      return graph.getVertexDegree( vertexIdx ) >= 2;
   };
 
   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };
 
   auto store =
      [ = ] __cuda_callable__(
         int indexOfVertexIdx, int vertexIdx, int localIdx, int targetIdx, float minWeight, bool isolatedVertex ) mutable
   {
      compressedVertexMinWeights_view[ indexOfVertexIdx ] = minWeight;
      vertexMinWeights_view[ vertexIdx ] = minWeight;
      if( ! isolatedVertex ) {
         compressedVertexMinTargets_view[ indexOfVertexIdx ] = targetIdx;
         vertexMinTargets_view[ vertexIdx ] = targetIdx;
      }
   };
 
   int traversedVertexCount =
      TNL::Graphs::reduceVerticesWithArgumentIf( graph, 1, 4, condition, fetch, TNL::MinWithArg{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Number of traversed vertices: " << traversedVertexCount << '\n';
   std::cout << "Minimum edge weight for vertices 1-3 with degree >= 2:" << vertexMinWeights << '\n';
   std::cout << "Target vertex for minimum edge:" << vertexMinTargets << '\n';
   std::cout << "Compressed minimum weights:" << compressedVertexMinWeights.getView( 0, traversedVertexCount ) << '\n';
   std::cout << "Compressed minimum targets:" << compressedVertexMinTargets.getView( 0, traversedVertexCount ) << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesWithArgumentIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesWithArgumentIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of traversed vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Target vertex for minimum edge:[ -1, 2, -1, 0, -1 ]
Compressed minimum weights:[ 30, 70 ]
Compressed minimum targets:[ 2, 0 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of traversed vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Target vertex for minimum edge:[ -1, 2, -1, 0, -1 ]
Compressed minimum weights:[ 30, 70 ]
Compressed minimum targets:[ 2, 0 ]

reduceAllVerticesWithArgumentIf() [2/4]

template<typename Graph, typename Condition, typename Fetch, typename Reduction, typename Store>

Graph::IndexType TNL::Graphs::reduceAllVerticesWithArgumentIf	(	const Graph &	graph,
		Condition &&	condition,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over all vertices based on a condition while returning also the position of the edge of interest with automatic identity deduction (const version).

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Condition	The type of the lambda function used for the condition check.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.

Parameters

graph	The graph on which the reduction will be performed.
condition	Lambda function for vertex condition checking. See Condition Check.
fetch	Lambda function for fetching data. See For Const Graphs.
reduction	Function object for reduction with argument tracking. See Reduction Function Objects.
store	Lambda function for storing results with position tracking. See Store With Argument (Position Tracking).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Returns

The number of processed vertices, i.e. vertices for which the condition was true.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesWithArgumentIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Find minimum edge weight and target vertex for vertices in range [1, 4) with degree >= 2.
    */
   TNL::Containers::Vector< float, Device > vertexMinWeights( 5, -1 );
   TNL::Containers::Vector< float, Device > compressedVertexMinWeights( 5 );
   TNL::Containers::Vector< int, Device > vertexMinTargets( 5, -1 );
   TNL::Containers::Vector< int, Device > compressedVertexMinTargets( 5 );
   auto vertexMinWeights_view = vertexMinWeights.getView();
   auto compressedVertexMinWeights_view = compressedVertexMinWeights.getView();
   auto vertexMinTargets_view = vertexMinTargets.getView();
   auto compressedVertexMinTargets_view = compressedVertexMinTargets.getView();
 
   auto condition = [ = ] __cuda_callable__( int vertexIdx ) -> bool
   {
      return graph.getVertexDegree( vertexIdx ) >= 2;
   };
 
   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };
 
   auto store =
      [ = ] __cuda_callable__(
         int indexOfVertexIdx, int vertexIdx, int localIdx, int targetIdx, float minWeight, bool isolatedVertex ) mutable
   {
      compressedVertexMinWeights_view[ indexOfVertexIdx ] = minWeight;
      vertexMinWeights_view[ vertexIdx ] = minWeight;
      if( ! isolatedVertex ) {
         compressedVertexMinTargets_view[ indexOfVertexIdx ] = targetIdx;
         vertexMinTargets_view[ vertexIdx ] = targetIdx;
      }
   };
 
   int traversedVertexCount =
      TNL::Graphs::reduceVerticesWithArgumentIf( graph, 1, 4, condition, fetch, TNL::MinWithArg{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Number of traversed vertices: " << traversedVertexCount << '\n';
   std::cout << "Minimum edge weight for vertices 1-3 with degree >= 2:" << vertexMinWeights << '\n';
   std::cout << "Target vertex for minimum edge:" << vertexMinTargets << '\n';
   std::cout << "Compressed minimum weights:" << compressedVertexMinWeights.getView( 0, traversedVertexCount ) << '\n';
   std::cout << "Compressed minimum targets:" << compressedVertexMinTargets.getView( 0, traversedVertexCount ) << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesWithArgumentIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesWithArgumentIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of traversed vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Target vertex for minimum edge:[ -1, 2, -1, 0, -1 ]
Compressed minimum weights:[ 30, 70 ]
Compressed minimum targets:[ 2, 0 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of traversed vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Target vertex for minimum edge:[ -1, 2, -1, 0, -1 ]
Compressed minimum weights:[ 30, 70 ]
Compressed minimum targets:[ 2, 0 ]

reduceAllVerticesWithArgumentIf() [3/4]

template<typename Graph, typename Condition, typename Fetch, typename Reduction, typename Store, typename FetchValue = decltype( std::declval< Fetch >()( 0, 0, std::declval< typename Graph::RealType >() ) )>

Graph::IndexType TNL::Graphs::reduceAllVerticesWithArgumentIf	(	Graph &	graph,
		Condition &&	condition,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		const FetchValue &	identity,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over all vertices based on a condition while returning also the position of the edge of interest.

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Condition	The type of the lambda function used for the condition check.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.
FetchValue	The type returned by the Fetch lambda function.

Parameters

graph	The graph on which the reduction will be performed.
condition	Lambda function for vertex condition checking. See Condition Check.
fetch	Lambda function for fetching data. See For Non-Const Graphs.
reduction	Function object for reduction with argument tracking. See Reduction Function Objects.
store	Lambda function for storing results with position tracking. See Store With Argument (Position Tracking).
identity	The identity edge for the reduction operation.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Returns

The number of processed vertices, i.e. vertices for which the condition was true.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesWithArgumentIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Find minimum edge weight and target vertex for vertices in range [1, 4) with degree >= 2.
    */
   TNL::Containers::Vector< float, Device > vertexMinWeights( 5, -1 );
   TNL::Containers::Vector< float, Device > compressedVertexMinWeights( 5 );
   TNL::Containers::Vector< int, Device > vertexMinTargets( 5, -1 );
   TNL::Containers::Vector< int, Device > compressedVertexMinTargets( 5 );
   auto vertexMinWeights_view = vertexMinWeights.getView();
   auto compressedVertexMinWeights_view = compressedVertexMinWeights.getView();
   auto vertexMinTargets_view = vertexMinTargets.getView();
   auto compressedVertexMinTargets_view = compressedVertexMinTargets.getView();
 
   auto condition = [ = ] __cuda_callable__( int vertexIdx ) -> bool
   {
      return graph.getVertexDegree( vertexIdx ) >= 2;
   };
 
   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };
 
   auto store =
      [ = ] __cuda_callable__(
         int indexOfVertexIdx, int vertexIdx, int localIdx, int targetIdx, float minWeight, bool isolatedVertex ) mutable
   {
      compressedVertexMinWeights_view[ indexOfVertexIdx ] = minWeight;
      vertexMinWeights_view[ vertexIdx ] = minWeight;
      if( ! isolatedVertex ) {
         compressedVertexMinTargets_view[ indexOfVertexIdx ] = targetIdx;
         vertexMinTargets_view[ vertexIdx ] = targetIdx;
      }
   };
 
   int traversedVertexCount =
      TNL::Graphs::reduceVerticesWithArgumentIf( graph, 1, 4, condition, fetch, TNL::MinWithArg{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Number of traversed vertices: " << traversedVertexCount << '\n';
   std::cout << "Minimum edge weight for vertices 1-3 with degree >= 2:" << vertexMinWeights << '\n';
   std::cout << "Target vertex for minimum edge:" << vertexMinTargets << '\n';
   std::cout << "Compressed minimum weights:" << compressedVertexMinWeights.getView( 0, traversedVertexCount ) << '\n';
   std::cout << "Compressed minimum targets:" << compressedVertexMinTargets.getView( 0, traversedVertexCount ) << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesWithArgumentIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesWithArgumentIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of traversed vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Target vertex for minimum edge:[ -1, 2, -1, 0, -1 ]
Compressed minimum weights:[ 30, 70 ]
Compressed minimum targets:[ 2, 0 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of traversed vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Target vertex for minimum edge:[ -1, 2, -1, 0, -1 ]
Compressed minimum weights:[ 30, 70 ]
Compressed minimum targets:[ 2, 0 ]

reduceAllVerticesWithArgumentIf() [4/4]

template<typename Graph, typename Condition, typename Fetch, typename Reduction, typename Store>

Graph::IndexType TNL::Graphs::reduceAllVerticesWithArgumentIf	(	Graph &	graph,
		Condition &&	condition,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over all vertices based on a condition while returning also the position of the edge of interest with automatic identity deduction.

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Condition	The type of the lambda function used for the condition check.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.

Parameters

graph	The graph on which the reduction will be performed.
condition	Lambda function for vertex condition checking. See Condition Check.
fetch	Lambda function for fetching data. See For Non-Const Graphs.
reduction	Function object for reduction with argument tracking. See Reduction Function Objects.
store	Lambda function for storing results with position tracking. See Store With Argument (Position Tracking).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Returns

The number of processed vertices, i.e. vertices for which the condition was true.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesWithArgumentIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Find minimum edge weight and target vertex for vertices in range [1, 4) with degree >= 2.
    */
   TNL::Containers::Vector< float, Device > vertexMinWeights( 5, -1 );
   TNL::Containers::Vector< float, Device > compressedVertexMinWeights( 5 );
   TNL::Containers::Vector< int, Device > vertexMinTargets( 5, -1 );
   TNL::Containers::Vector< int, Device > compressedVertexMinTargets( 5 );
   auto vertexMinWeights_view = vertexMinWeights.getView();
   auto compressedVertexMinWeights_view = compressedVertexMinWeights.getView();
   auto vertexMinTargets_view = vertexMinTargets.getView();
   auto compressedVertexMinTargets_view = compressedVertexMinTargets.getView();
 
   auto condition = [ = ] __cuda_callable__( int vertexIdx ) -> bool
   {
      return graph.getVertexDegree( vertexIdx ) >= 2;
   };
 
   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };
 
   auto store =
      [ = ] __cuda_callable__(
         int indexOfVertexIdx, int vertexIdx, int localIdx, int targetIdx, float minWeight, bool isolatedVertex ) mutable
   {
      compressedVertexMinWeights_view[ indexOfVertexIdx ] = minWeight;
      vertexMinWeights_view[ vertexIdx ] = minWeight;
      if( ! isolatedVertex ) {
         compressedVertexMinTargets_view[ indexOfVertexIdx ] = targetIdx;
         vertexMinTargets_view[ vertexIdx ] = targetIdx;
      }
   };
 
   int traversedVertexCount =
      TNL::Graphs::reduceVerticesWithArgumentIf( graph, 1, 4, condition, fetch, TNL::MinWithArg{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Number of traversed vertices: " << traversedVertexCount << '\n';
   std::cout << "Minimum edge weight for vertices 1-3 with degree >= 2:" << vertexMinWeights << '\n';
   std::cout << "Target vertex for minimum edge:" << vertexMinTargets << '\n';
   std::cout << "Compressed minimum weights:" << compressedVertexMinWeights.getView( 0, traversedVertexCount ) << '\n';
   std::cout << "Compressed minimum targets:" << compressedVertexMinTargets.getView( 0, traversedVertexCount ) << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesWithArgumentIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesWithArgumentIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of traversed vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Target vertex for minimum edge:[ -1, 2, -1, 0, -1 ]
Compressed minimum weights:[ 30, 70 ]
Compressed minimum targets:[ 2, 0 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of traversed vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Target vertex for minimum edge:[ -1, 2, -1, 0, -1 ]
Compressed minimum weights:[ 30, 70 ]
Compressed minimum targets:[ 2, 0 ]

reduceVertices() [1/8]

template<typename Graph, typename Array, typename Fetch, typename Reduction, typename Store, typename FetchValue, typename T = typename std::enable_if_t< IsArrayType< Array >::value >>

void TNL::Graphs::reduceVertices	(	const Graph &	graph,
		const Array &	vertexIndexes,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		const FetchValue &	identity,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within graph vertices specified by a given set of vertex indexes (const version).

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Array	The type of the array containing the indexes of the vertices to iterate over.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.
FetchValue	The type returned by the Fetch lambda function.

Parameters

graph	The graph on which the reduction will be performed.
vertexIndexes	The array containing the indexes of the vertices to iterate over.
fetch	Lambda function for fetching data. See For Const Graphs.
reduction	Lambda function for reduction operation. See Basic Reduction (Without Arguments).
store	Lambda function for storing results. See Store With Vertex Index Array Or Condition.
identity	The initial value for the reduction operation.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesWithIndexesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Compute sum of edge weights for specific vertices (0, 2, 3).
    */
   TNL::Containers::Vector< int, Device > vertexIndices( { 0, 2, 3 } );
   TNL::Containers::Vector< float, Device > vertexSums( 5, -1 );
   TNL::Containers::Vector< float, Device > compressedVertexSums( 3, -1 );
   auto vertexSums_view = vertexSums.getView();
   auto compressedVertexSums_view = compressedVertexSums.getView();
 
   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };
 
   auto store = [ = ] __cuda_callable__( int indexOfVertexIdx, int vertexIdx, const float& sum ) mutable
   {
      compressedVertexSums_view[ indexOfVertexIdx ] = sum;
      vertexSums_view[ vertexIdx ] = sum;
   };
 
   TNL::Graphs::reduceVertices( graph, vertexIndices, fetch, TNL::Plus{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Sum of edge weights for specific vertices:" << vertexSums << '\n';
   std::cout << "Compressed sums:" << compressedVertexSums.getView( 0, vertexIndices.getSize() ) << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesWithIndexesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesWithIndexesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Sum of edge weights for specific vertices:[ 30, -1, 60, 150, -1 ]
Compressed sums:[ 30, 60, 150 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Sum of edge weights for specific vertices:[ 30, -1, 60, 150, -1 ]
Compressed sums:[ 30, 60, 150 ]

reduceVertices() [2/8]

template<typename Graph, typename Array, typename Fetch, typename Reduction, typename Store, typename T = typename std::enable_if_t< IsArrayType< Array >::value >>

void TNL::Graphs::reduceVertices	(	const Graph &	graph,
		const Array &	vertexIndexes,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within graph vertices specified by a given set of vertex indexes with automatic identity deduction (const version).

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Array	The type of the array containing the indexes of the vertices to iterate over.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.

Parameters

graph	The graph on which the reduction will be performed.
vertexIndexes	The array containing the indexes of the vertices to iterate over.
fetch	Lambda function for fetching data. See For Const Graphs.
reduction	Function object for reduction operation. See Reduction Function Objects.
store	Lambda function for storing results. See Store With Vertex Index Array Or Condition.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesWithIndexesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Compute sum of edge weights for specific vertices (0, 2, 3).
    */
   TNL::Containers::Vector< int, Device > vertexIndices( { 0, 2, 3 } );
   TNL::Containers::Vector< float, Device > vertexSums( 5, -1 );
   TNL::Containers::Vector< float, Device > compressedVertexSums( 3, -1 );
   auto vertexSums_view = vertexSums.getView();
   auto compressedVertexSums_view = compressedVertexSums.getView();
 
   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };
 
   auto store = [ = ] __cuda_callable__( int indexOfVertexIdx, int vertexIdx, const float& sum ) mutable
   {
      compressedVertexSums_view[ indexOfVertexIdx ] = sum;
      vertexSums_view[ vertexIdx ] = sum;
   };
 
   TNL::Graphs::reduceVertices( graph, vertexIndices, fetch, TNL::Plus{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Sum of edge weights for specific vertices:" << vertexSums << '\n';
   std::cout << "Compressed sums:" << compressedVertexSums.getView( 0, vertexIndices.getSize() ) << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesWithIndexesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesWithIndexesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Sum of edge weights for specific vertices:[ 30, -1, 60, 150, -1 ]
Compressed sums:[ 30, 60, 150 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Sum of edge weights for specific vertices:[ 30, -1, 60, 150, -1 ]
Compressed sums:[ 30, 60, 150 ]

reduceVertices() [3/8]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Fetch, typename Reduction, typename Store, typename FetchValue, typename T = typename std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>

void TNL::Graphs::reduceVertices	(	const Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		const FetchValue &	identity,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over a given range of vertex indexes (const version).

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices where the reduction will be performed.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.
FetchValue	The type returned by the Fetch lambda function.

Parameters

graph	The graph on which the reduction will be performed.
begin	The beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
end	The end of the interval [ begin, end ) of vertices where the reduction will be performed.
fetch	Lambda function for fetching data. See For Const Graphs.
reduction	Lambda function for the reduction operation. See Basic Reduction (Without Arguments).
store	Lambda function for storing results. See Basic Store (Vertex Index Only).
identity	The initial value for the reduction operation.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';
 
   /***
    * Compute maximum edge weight for vertices in range [1, 4).
    */
   TNL::Containers::Vector< float, Device > vertexMaxWeights( 5, -1 );
   auto vertexMaxWeights_view = vertexMaxWeights.getView();

   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };

   auto store = [ = ] __cuda_callable__( int vertexIdx, const float& maxWeight ) mutable
   {
      vertexMaxWeights_view[ vertexIdx ] = maxWeight;
   };

   TNL::Graphs::reduceVertices( graph, 1, 4, fetch, TNL::Max{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Maximum edge weight for vertices 1-3:" << vertexMaxWeights << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Maximum edge weight for vertices 1-3:[ -1, 50, 60, 80, -1 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Maximum edge weight for vertices 1-3:[ -1, 50, 60, 80, -1 ]

reduceVertices() [4/8]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Fetch, typename Reduction, typename Store, typename T = typename std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>

void TNL::Graphs::reduceVertices	(	const Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over a given range of vertex indexes with automatic identity deduction (const version).

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices where the reduction will be performed.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.

Parameters

graph	The graph on which the reduction will be performed.
begin	The beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
end	The end of the interval [ begin, end ) of vertices where the reduction will be performed.
fetch	Lambda function for fetching data. See For Const Graphs.
reduction	Function object for reduction operation. See Reduction Function Objects.
store	Lambda function for storing results. See Basic Store (Vertex Index Only).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';
 
   /***
    * Compute maximum edge weight for vertices in range [1, 4).
    */
   TNL::Containers::Vector< float, Device > vertexMaxWeights( 5, -1 );
   auto vertexMaxWeights_view = vertexMaxWeights.getView();

   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };

   auto store = [ = ] __cuda_callable__( int vertexIdx, const float& maxWeight ) mutable
   {
      vertexMaxWeights_view[ vertexIdx ] = maxWeight;
   };

   TNL::Graphs::reduceVertices( graph, 1, 4, fetch, TNL::Max{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Maximum edge weight for vertices 1-3:" << vertexMaxWeights << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Maximum edge weight for vertices 1-3:[ -1, 50, 60, 80, -1 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Maximum edge weight for vertices 1-3:[ -1, 50, 60, 80, -1 ]

reduceVertices() [5/8]

template<typename Graph, typename Array, typename Fetch, typename Reduction, typename Store, typename FetchValue, typename T = typename std::enable_if_t< IsArrayType< Array >::value >>

void TNL::Graphs::reduceVertices	(	Graph &	graph,
		const Array &	vertexIndexes,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		const FetchValue &	identity,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within graph vertices specified by a given set of vertex indexes.

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Array	The type of the array containing the indexes of the vertices to iterate over.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertex indexes where the reduction will be performed.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertex indexes where the reduction will be performed.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.
FetchValue	The type returned by the Fetch lambda function.

Parameters

graph	The graph on which the reduction will be performed.
vertexIndexes	The array containing the indexes of the vertices to iterate over.
fetch	Lambda function for fetching data. See For Non-Const Graphs.
reduction	Lambda function for reduction operation. See Basic Reduction (Without Arguments).
store	Lambda function for storing results. See Store With Vertex Index Array Or Condition.
identity	The initial value for the reduction operation.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesWithIndexesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Compute sum of edge weights for specific vertices (0, 2, 3).
    */
   TNL::Containers::Vector< int, Device > vertexIndices( { 0, 2, 3 } );
   TNL::Containers::Vector< float, Device > vertexSums( 5, -1 );
   TNL::Containers::Vector< float, Device > compressedVertexSums( 3, -1 );
   auto vertexSums_view = vertexSums.getView();
   auto compressedVertexSums_view = compressedVertexSums.getView();
 
   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };
 
   auto store = [ = ] __cuda_callable__( int indexOfVertexIdx, int vertexIdx, const float& sum ) mutable
   {
      compressedVertexSums_view[ indexOfVertexIdx ] = sum;
      vertexSums_view[ vertexIdx ] = sum;
   };
 
   TNL::Graphs::reduceVertices( graph, vertexIndices, fetch, TNL::Plus{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Sum of edge weights for specific vertices:" << vertexSums << '\n';
   std::cout << "Compressed sums:" << compressedVertexSums.getView( 0, vertexIndices.getSize() ) << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesWithIndexesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesWithIndexesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Sum of edge weights for specific vertices:[ 30, -1, 60, 150, -1 ]
Compressed sums:[ 30, 60, 150 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Sum of edge weights for specific vertices:[ 30, -1, 60, 150, -1 ]
Compressed sums:[ 30, 60, 150 ]

reduceVertices() [6/8]

template<typename Graph, typename Array, typename Fetch, typename Reduction, typename Store, typename T = typename std::enable_if_t< IsArrayType< Array >::value >>

void TNL::Graphs::reduceVertices	(	Graph &	graph,
		const Array &	vertexIndexes,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within graph vertices specified by a given set of vertex indexes with automatic identity deduction.

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Array	The type of the array containing the indexes of the vertices to iterate over.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.

Parameters

graph	The graph on which the reduction will be performed.
vertexIndexes	The array containing the indexes of the vertices to iterate over.
fetch	Lambda function for fetching data. See For Non-Const Graphs.
reduction	Function object for reduction operation. See Reduction Function Objects.
store	Lambda function for storing results. See Store With Vertex Index Array Or Condition.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesWithIndexesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Compute sum of edge weights for specific vertices (0, 2, 3).
    */
   TNL::Containers::Vector< int, Device > vertexIndices( { 0, 2, 3 } );
   TNL::Containers::Vector< float, Device > vertexSums( 5, -1 );
   TNL::Containers::Vector< float, Device > compressedVertexSums( 3, -1 );
   auto vertexSums_view = vertexSums.getView();
   auto compressedVertexSums_view = compressedVertexSums.getView();
 
   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };
 
   auto store = [ = ] __cuda_callable__( int indexOfVertexIdx, int vertexIdx, const float& sum ) mutable
   {
      compressedVertexSums_view[ indexOfVertexIdx ] = sum;
      vertexSums_view[ vertexIdx ] = sum;
   };
 
   TNL::Graphs::reduceVertices( graph, vertexIndices, fetch, TNL::Plus{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Sum of edge weights for specific vertices:" << vertexSums << '\n';
   std::cout << "Compressed sums:" << compressedVertexSums.getView( 0, vertexIndices.getSize() ) << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesWithIndexesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesWithIndexesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Sum of edge weights for specific vertices:[ 30, -1, 60, 150, -1 ]
Compressed sums:[ 30, 60, 150 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Sum of edge weights for specific vertices:[ 30, -1, 60, 150, -1 ]
Compressed sums:[ 30, 60, 150 ]

reduceVertices() [7/8]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Fetch, typename Reduction, typename Store, typename FetchValue, typename T = typename std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>

void TNL::Graphs::reduceVertices	(	Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		const FetchValue &	identity,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over a given range of vertex indexes.

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices where the reduction will be performed.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.
FetchValue	The type returned by the Fetch lambda function.

Parameters

graph	The graph on which the reduction will be performed.
begin	The beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
end	The end of the interval [ begin, end ) of vertices where the reduction will be performed.
fetch	Lambda function for fetching data. See For Non-Const Graphs.
reduction	Lambda function for the reduction operation. See Basic Reduction (Without Arguments).
store	Lambda function for storing results. See Basic Store (Vertex Index Only).
identity	The initial value for the reduction operation.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';
 
   /***
    * Compute maximum edge weight for vertices in range [1, 4).
    */
   TNL::Containers::Vector< float, Device > vertexMaxWeights( 5, -1 );
   auto vertexMaxWeights_view = vertexMaxWeights.getView();

   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };

   auto store = [ = ] __cuda_callable__( int vertexIdx, const float& maxWeight ) mutable
   {
      vertexMaxWeights_view[ vertexIdx ] = maxWeight;
   };

   TNL::Graphs::reduceVertices( graph, 1, 4, fetch, TNL::Max{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Maximum edge weight for vertices 1-3:" << vertexMaxWeights << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Maximum edge weight for vertices 1-3:[ -1, 50, 60, 80, -1 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Maximum edge weight for vertices 1-3:[ -1, 50, 60, 80, -1 ]

reduceVertices() [8/8]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Fetch, typename Reduction, typename Store, typename T = typename std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>

void TNL::Graphs::reduceVertices	(	Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over a given range of vertex indexes with automatic identity deduction.

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices where the reduction will be performed.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.

Parameters

graph	The graph on which the reduction will be performed.
begin	The beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
end	The end of the interval [ begin, end ) of vertices where the reduction will be performed.
fetch	Lambda function for fetching data. See For Non-Const Graphs.
reduction	Function object for reduction operation. See Reduction Function Objects.
store	Lambda function for storing results. See Basic Store (Vertex Index Only).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';
 
   /***
    * Compute maximum edge weight for vertices in range [1, 4).
    */
   TNL::Containers::Vector< float, Device > vertexMaxWeights( 5, -1 );
   auto vertexMaxWeights_view = vertexMaxWeights.getView();

   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };

   auto store = [ = ] __cuda_callable__( int vertexIdx, const float& maxWeight ) mutable
   {
      vertexMaxWeights_view[ vertexIdx ] = maxWeight;
   };

   TNL::Graphs::reduceVertices( graph, 1, 4, fetch, TNL::Max{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Maximum edge weight for vertices 1-3:" << vertexMaxWeights << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Maximum edge weight for vertices 1-3:[ -1, 50, 60, 80, -1 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Maximum edge weight for vertices 1-3:[ -1, 50, 60, 80, -1 ]

reduceVerticesIf() [1/4]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Condition, typename Fetch, typename Reduction, typename Store, typename FetchValue>

Graph::IndexType TNL::Graphs::reduceVerticesIf	(	const Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Condition &&	condition,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		const FetchValue &	identity,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over a given range of vertex indexes based on a condition (const version).

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices where the reduction will be performed.
Condition	The type of the lambda function used for the condition check.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.
FetchValue	The type returned by the Fetch lambda function.

Parameters

graph	The graph on which the reduction will be performed.
begin	The beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
end	The end of the interval [ begin, end ) of vertices where the reduction will be performed.
condition	Lambda function for condition check. See Condition Check.
fetch	Lambda function for fetching data. See For Const Graphs.
reduction	Lambda function for reduction operation. See Basic Reduction (Without Arguments).
store	Lambda function for storing results. See Basic Store (Vertex Index Only).
identity	The initial value for the reduction operation.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Returns

The number of processed vertices, i.e. vertices for which the condition was true.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Compute minimum edge weight for vertices in range [1, 4) with degree >= 2.
    */
   TNL::Containers::Vector< float, Device > vertexMinWeights( 5, -1 );
   TNL::Containers::Vector< float, Device > compressedVertexMinWeights( 5 );
   auto vertexMinWeights_view = vertexMinWeights.getView();
   auto compressedVertexMinWeights_view = compressedVertexMinWeights.getView();
 
   auto condition = [ = ] __cuda_callable__( int vertexIdx ) -> bool
   {
      return graph.getVertexDegree( vertexIdx ) >= 2;
   };
 
   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };
 
   auto store = [ = ] __cuda_callable__( int indexOfVertexIdx, int vertexIdx, const float& minWeight ) mutable
   {
      compressedVertexMinWeights_view[ indexOfVertexIdx ] = minWeight;
      vertexMinWeights_view[ vertexIdx ] = minWeight;
   };
 
   int reducedVertexCount = TNL::Graphs::reduceVerticesIf( graph, 1, 4, condition, fetch, TNL::Min{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Number of reduced vertices: " << reducedVertexCount << '\n';
   std::cout << "Minimum edge weight for vertices 1-3 with degree >= 2:" << vertexMinWeights << '\n';
   std::cout << "Compressed minimum weights:" << compressedVertexMinWeights.getView( 0, reducedVertexCount ) << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of reduced vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Compressed minimum weights:[ 30, 70 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of reduced vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Compressed minimum weights:[ 30, 70 ]

reduceVerticesIf() [2/4]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Condition, typename Fetch, typename Reduction, typename Store>

Graph::IndexType TNL::Graphs::reduceVerticesIf	(	const Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Condition &&	condition,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over a given range of vertex indexes based on a condition with automatic identity deduction (const version).

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices where the reduction will be performed.
Condition	The type of the lambda function used for the condition check.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.

Parameters

graph	The graph on which the reduction will be performed.
begin	The beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
end	The end of the interval [ begin, end ) of vertices where the reduction will be performed.
condition	Lambda function for condition check. See Condition Check.
fetch	Lambda function for fetching data. See For Const Graphs.
reduction	Function object for reduction operation. See Reduction Function Objects.
store	Lambda function for storing results. See Basic Store (Vertex Index Only).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Returns

The number of processed vertices, i.e. vertices for which the condition was true.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Compute minimum edge weight for vertices in range [1, 4) with degree >= 2.
    */
   TNL::Containers::Vector< float, Device > vertexMinWeights( 5, -1 );
   TNL::Containers::Vector< float, Device > compressedVertexMinWeights( 5 );
   auto vertexMinWeights_view = vertexMinWeights.getView();
   auto compressedVertexMinWeights_view = compressedVertexMinWeights.getView();
 
   auto condition = [ = ] __cuda_callable__( int vertexIdx ) -> bool
   {
      return graph.getVertexDegree( vertexIdx ) >= 2;
   };
 
   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };
 
   auto store = [ = ] __cuda_callable__( int indexOfVertexIdx, int vertexIdx, const float& minWeight ) mutable
   {
      compressedVertexMinWeights_view[ indexOfVertexIdx ] = minWeight;
      vertexMinWeights_view[ vertexIdx ] = minWeight;
   };
 
   int reducedVertexCount = TNL::Graphs::reduceVerticesIf( graph, 1, 4, condition, fetch, TNL::Min{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Number of reduced vertices: " << reducedVertexCount << '\n';
   std::cout << "Minimum edge weight for vertices 1-3 with degree >= 2:" << vertexMinWeights << '\n';
   std::cout << "Compressed minimum weights:" << compressedVertexMinWeights.getView( 0, reducedVertexCount ) << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of reduced vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Compressed minimum weights:[ 30, 70 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of reduced vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Compressed minimum weights:[ 30, 70 ]

reduceVerticesIf() [3/4]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Condition, typename Fetch, typename Reduction, typename Store, typename FetchValue>

Graph::IndexType TNL::Graphs::reduceVerticesIf	(	Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Condition &&	condition,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		const FetchValue &	identity,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over a given range of vertex indexes based on a condition.

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices where the reduction will be performed.
Condition	The type of the lambda function used for the condition check.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.
FetchValue	The type returned by the Fetch lambda function.

Parameters

graph	The graph on which the reduction will be performed.
begin	The beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
end	The end of the interval [ begin, end ) of vertices where the reduction will be performed.
condition	Lambda function for condition check. See Condition Check.
fetch	Lambda function for fetching data. See For Non-Const Graphs.
reduction	Lambda function for reduction operation. See Basic Reduction (Without Arguments).
store	Lambda function for storing results. See Basic Store (Vertex Index Only).
identity	The initial value for the reduction operation.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Returns

The number of processed vertices, i.e. vertices for which the condition was true.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Compute minimum edge weight for vertices in range [1, 4) with degree >= 2.
    */
   TNL::Containers::Vector< float, Device > vertexMinWeights( 5, -1 );
   TNL::Containers::Vector< float, Device > compressedVertexMinWeights( 5 );
   auto vertexMinWeights_view = vertexMinWeights.getView();
   auto compressedVertexMinWeights_view = compressedVertexMinWeights.getView();
 
   auto condition = [ = ] __cuda_callable__( int vertexIdx ) -> bool
   {
      return graph.getVertexDegree( vertexIdx ) >= 2;
   };
 
   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };
 
   auto store = [ = ] __cuda_callable__( int indexOfVertexIdx, int vertexIdx, const float& minWeight ) mutable
   {
      compressedVertexMinWeights_view[ indexOfVertexIdx ] = minWeight;
      vertexMinWeights_view[ vertexIdx ] = minWeight;
   };
 
   int reducedVertexCount = TNL::Graphs::reduceVerticesIf( graph, 1, 4, condition, fetch, TNL::Min{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Number of reduced vertices: " << reducedVertexCount << '\n';
   std::cout << "Minimum edge weight for vertices 1-3 with degree >= 2:" << vertexMinWeights << '\n';
   std::cout << "Compressed minimum weights:" << compressedVertexMinWeights.getView( 0, reducedVertexCount ) << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of reduced vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Compressed minimum weights:[ 30, 70 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of reduced vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Compressed minimum weights:[ 30, 70 ]

reduceVerticesIf() [4/4]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Condition, typename Fetch, typename Reduction, typename Store>

Graph::IndexType TNL::Graphs::reduceVerticesIf	(	Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Condition &&	condition,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over a given range of vertex indexes based on a condition with automatic identity deduction.

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices where the reduction will be performed.
Condition	The type of the lambda function used for the condition check.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.

Parameters

graph	The graph on which the reduction will be performed.
begin	The beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
end	The end of the interval [ begin, end ) of vertices where the reduction will be performed.
condition	Lambda function for condition check. See Condition Check.
fetch	Lambda function for fetching data. See For Non-Const Graphs.
reduction	Function object for reduction operation. See Reduction Function Objects.
store	Lambda function for storing results. See Basic Store (Vertex Index Only).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Returns

The number of processed vertices, i.e. vertices for which the condition was true.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Compute minimum edge weight for vertices in range [1, 4) with degree >= 2.
    */
   TNL::Containers::Vector< float, Device > vertexMinWeights( 5, -1 );
   TNL::Containers::Vector< float, Device > compressedVertexMinWeights( 5 );
   auto vertexMinWeights_view = vertexMinWeights.getView();
   auto compressedVertexMinWeights_view = compressedVertexMinWeights.getView();
 
   auto condition = [ = ] __cuda_callable__( int vertexIdx ) -> bool
   {
      return graph.getVertexDegree( vertexIdx ) >= 2;
   };
 
   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };
 
   auto store = [ = ] __cuda_callable__( int indexOfVertexIdx, int vertexIdx, const float& minWeight ) mutable
   {
      compressedVertexMinWeights_view[ indexOfVertexIdx ] = minWeight;
      vertexMinWeights_view[ vertexIdx ] = minWeight;
   };
 
   int reducedVertexCount = TNL::Graphs::reduceVerticesIf( graph, 1, 4, condition, fetch, TNL::Min{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Number of reduced vertices: " << reducedVertexCount << '\n';
   std::cout << "Minimum edge weight for vertices 1-3 with degree >= 2:" << vertexMinWeights << '\n';
   std::cout << "Compressed minimum weights:" << compressedVertexMinWeights.getView( 0, reducedVertexCount ) << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of reduced vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Compressed minimum weights:[ 30, 70 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of reduced vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Compressed minimum weights:[ 30, 70 ]

reduceVerticesWithArgument() [1/8]

template<typename Graph, typename Array, typename Fetch, typename Reduction, typename Store, typename FetchValue, typename T = typename std::enable_if_t< IsArrayType< Array >::value >>

void TNL::Graphs::reduceVerticesWithArgument	(	const Graph &	graph,
		const Array &	vertexIndexes,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		const FetchValue &	identity,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within graph vertices specified by a given set of vertex indexes while returning also the position of the edge of interest (const version).

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Array	The type of the array containing the indexes of the vertices to iterate over.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.
FetchValue	The type returned by the Fetch lambda function.

Parameters

graph	The graph on which the reduction will be performed.
vertexIndexes	The array containing the indexes of the vertices to iterate over.
fetch	Lambda function for fetching data. See For Const Graphs.
reduction	Lambda function for reduction with argument tracking. See Reduction With Argument (Position Tracking).
store	Lambda function for storing results with position tracking. See Store With Vertex Index Array and With Argument.
identity	The initial value for the reduction operation.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesWithArgumentExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';
 
   /***
    * Find minimum edge weight and target vertex for vertices in range [1, 4).
    */
   TNL::Containers::Vector< float, Device > minWeights( 5, -1 );
   TNL::Containers::Vector< int, Device > minTargets( 5, -1 );
   auto minWeights_view = minWeights.getView();
   auto minTargets_view = minTargets.getView();

   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };

   auto store = [ = ] __cuda_callable__( int vertexIdx, int localIdx, int targetIdx, float result, bool isolatedVertex ) mutable
   {
      minWeights_view[ vertexIdx ] = result;
      if( ! isolatedVertex )
         minTargets_view[ vertexIdx ] = targetIdx;
   };

   TNL::Graphs::reduceVerticesWithArgument( graph, 1, 5, fetch, TNL::MinWithArg{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Minimum edge weight for vertices 1-4:" << minWeights << '\n';
   std::cout << "Target vertex for minimum edge:" << minTargets << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesWithArgumentExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesWithArgumentExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Minimum edge weight for vertices 1-4:[ -1, 30, 60, 70, 3.40282e+38 ]
Target vertex for minimum edge:[ -1, 2, 3, 0, -1 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Minimum edge weight for vertices 1-4:[ -1, 30, 60, 70, 3.40282e+38 ]
Target vertex for minimum edge:[ -1, 2, 3, 0, -1 ]

reduceVerticesWithArgument() [2/8]

template<typename Graph, typename Array, typename Fetch, typename Reduction, typename Store, typename T = typename std::enable_if_t< IsArrayType< Array >::value >>

void TNL::Graphs::reduceVerticesWithArgument	(	const Graph &	graph,
		const Array &	vertexIndexes,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within graph vertices specified by a given set of vertex indexes while returning also the position of the edge of interest with automatic identity deduction (const version).

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Array	The type of the array containing the indexes of the vertices to iterate over.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.

Parameters

graph	The graph on which the reduction will be performed.
vertexIndexes	The array containing the indexes of the vertices to iterate over.
fetch	Lambda function for fetching data. See For Const Graphs.
reduction	Function object for reduction with argument tracking. See Reduction Function Objects.
store	Lambda function for storing results with position tracking. See Store With Vertex Index Array and With Argument.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesWithArgumentExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';
 
   /***
    * Find minimum edge weight and target vertex for vertices in range [1, 4).
    */
   TNL::Containers::Vector< float, Device > minWeights( 5, -1 );
   TNL::Containers::Vector< int, Device > minTargets( 5, -1 );
   auto minWeights_view = minWeights.getView();
   auto minTargets_view = minTargets.getView();

   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };

   auto store = [ = ] __cuda_callable__( int vertexIdx, int localIdx, int targetIdx, float result, bool isolatedVertex ) mutable
   {
      minWeights_view[ vertexIdx ] = result;
      if( ! isolatedVertex )
         minTargets_view[ vertexIdx ] = targetIdx;
   };

   TNL::Graphs::reduceVerticesWithArgument( graph, 1, 5, fetch, TNL::MinWithArg{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Minimum edge weight for vertices 1-4:" << minWeights << '\n';
   std::cout << "Target vertex for minimum edge:" << minTargets << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesWithArgumentExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesWithArgumentExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Minimum edge weight for vertices 1-4:[ -1, 30, 60, 70, 3.40282e+38 ]
Target vertex for minimum edge:[ -1, 2, 3, 0, -1 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Minimum edge weight for vertices 1-4:[ -1, 30, 60, 70, 3.40282e+38 ]
Target vertex for minimum edge:[ -1, 2, 3, 0, -1 ]

reduceVerticesWithArgument() [3/8]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Fetch, typename Reduction, typename Store, typename FetchValue, typename T = typename std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>

void TNL::Graphs::reduceVerticesWithArgument	(	const Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		const FetchValue &	identity,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over a given range of vertex indexes while returning also the position of the edge of interest (const version).

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices where the reduction will be performed.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.
FetchValue	The type returned by the Fetch lambda function.

Parameters

graph	The graph on which the reduction will be performed.
begin	The beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
end	The end of the interval [ begin, end ) of vertices where the reduction will be performed.
fetch	Lambda function for fetching data. See For Const Graphs.
reduction	Lambda function for reduction operation with argument. See Reduction With Argument (Position Tracking).
store	Lambda function for storing results. See Store With Argument (Position Tracking).
identity	The initial value for the reduction operation.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

reduceVerticesWithArgument() [4/8]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Fetch, typename Reduction, typename Store, typename T = typename std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>

void TNL::Graphs::reduceVerticesWithArgument	(	const Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over a given range of vertex indexes while returning also the position of the edge of interest with automatic identity deduction (const version).

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices where the reduction will be performed.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.

Parameters

graph	The graph on which the reduction will be performed.
begin	The beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
end	The end of the interval [ begin, end ) of vertices where the reduction will be performed.
fetch	Lambda function for fetching data. See For Const Graphs.
reduction	Function object for reduction operation with argument. See Reduction Function Objects.
store	Lambda function for storing results. See Store With Argument (Position Tracking).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

reduceVerticesWithArgument() [5/8]

template<typename Graph, typename Array, typename Fetch, typename Reduction, typename Store, typename FetchValue, typename T = typename std::enable_if_t< IsArrayType< Array >::value >>

void TNL::Graphs::reduceVerticesWithArgument	(	Graph &	graph,
		const Array &	vertexIndexes,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		const FetchValue &	identity,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within graph vertices specified by a given set of vertex indexes while returning also the position of the edge of interest.

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Array	The type of the array containing the indexes of the vertices to iterate over.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.
FetchValue	The type returned by the Fetch lambda function.

Parameters

graph	The graph on which the reduction will be performed.
vertexIndexes	The array containing the indexes of the vertices to iterate over.
fetch	Lambda function for fetching data. See For Non-Const Graphs.
reduction	Lambda function for reduction with argument tracking. See Reduction With Argument (Position Tracking).
store	Lambda function for storing results with position tracking. See Store With Vertex Index Array and With Argument.
identity	The initial value for the reduction operation.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesWithArgumentExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';
 
   /***
    * Find minimum edge weight and target vertex for vertices in range [1, 4).
    */
   TNL::Containers::Vector< float, Device > minWeights( 5, -1 );
   TNL::Containers::Vector< int, Device > minTargets( 5, -1 );
   auto minWeights_view = minWeights.getView();
   auto minTargets_view = minTargets.getView();

   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };

   auto store = [ = ] __cuda_callable__( int vertexIdx, int localIdx, int targetIdx, float result, bool isolatedVertex ) mutable
   {
      minWeights_view[ vertexIdx ] = result;
      if( ! isolatedVertex )
         minTargets_view[ vertexIdx ] = targetIdx;
   };

   TNL::Graphs::reduceVerticesWithArgument( graph, 1, 5, fetch, TNL::MinWithArg{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Minimum edge weight for vertices 1-4:" << minWeights << '\n';
   std::cout << "Target vertex for minimum edge:" << minTargets << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesWithArgumentExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesWithArgumentExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Minimum edge weight for vertices 1-4:[ -1, 30, 60, 70, 3.40282e+38 ]
Target vertex for minimum edge:[ -1, 2, 3, 0, -1 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Minimum edge weight for vertices 1-4:[ -1, 30, 60, 70, 3.40282e+38 ]
Target vertex for minimum edge:[ -1, 2, 3, 0, -1 ]

reduceVerticesWithArgument() [6/8]

template<typename Graph, typename Array, typename Fetch, typename Reduction, typename Store, typename T = typename std::enable_if_t< IsArrayType< Array >::value >>

void TNL::Graphs::reduceVerticesWithArgument	(	Graph &	graph,
		const Array &	vertexIndexes,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within graph vertices specified by a given set of vertex indexes while returning also the position of the edge of interest with automatic identity deduction.

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
Array	The type of the array containing the indexes of the vertices to iterate over.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.

Parameters

graph	The graph on which the reduction will be performed.
vertexIndexes	The array containing the indexes of the vertices to iterate over.
fetch	Lambda function for fetching data. See For Non-Const Graphs.
reduction	Function object for reduction with argument tracking. See Reduction Function Objects.
store	Lambda function for storing results with position tracking. See Store With Vertex Index Array and With Argument.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesWithArgumentExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';
 
   /***
    * Find minimum edge weight and target vertex for vertices in range [1, 4).
    */
   TNL::Containers::Vector< float, Device > minWeights( 5, -1 );
   TNL::Containers::Vector< int, Device > minTargets( 5, -1 );
   auto minWeights_view = minWeights.getView();
   auto minTargets_view = minTargets.getView();

   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };

   auto store = [ = ] __cuda_callable__( int vertexIdx, int localIdx, int targetIdx, float result, bool isolatedVertex ) mutable
   {
      minWeights_view[ vertexIdx ] = result;
      if( ! isolatedVertex )
         minTargets_view[ vertexIdx ] = targetIdx;
   };

   TNL::Graphs::reduceVerticesWithArgument( graph, 1, 5, fetch, TNL::MinWithArg{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Minimum edge weight for vertices 1-4:" << minWeights << '\n';
   std::cout << "Target vertex for minimum edge:" << minTargets << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesWithArgumentExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesWithArgumentExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Minimum edge weight for vertices 1-4:[ -1, 30, 60, 70, 3.40282e+38 ]
Target vertex for minimum edge:[ -1, 2, 3, 0, -1 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Minimum edge weight for vertices 1-4:[ -1, 30, 60, 70, 3.40282e+38 ]
Target vertex for minimum edge:[ -1, 2, 3, 0, -1 ]

reduceVerticesWithArgument() [7/8]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Fetch, typename Reduction, typename Store, typename FetchValue, typename T = typename std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>

void TNL::Graphs::reduceVerticesWithArgument	(	Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		const FetchValue &	identity,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over a given range of vertex indexes while returning also the position of the edge of interest.

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices where the reduction will be performed.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.
FetchValue	The type returned by the Fetch lambda function.

Parameters

graph	The graph on which the reduction will be performed.
begin	The beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
end	The end of the interval [ begin, end ) of vertices where the reduction will be performed.
fetch	Lambda function for fetching data. See For Non-Const Graphs.
reduction	Lambda function for reduction operation with argument. See Reduction With Argument (Position Tracking).
store	Lambda function for storing results. See Store With Argument (Position Tracking).
identity	The initial value for the reduction operation.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

reduceVerticesWithArgument() [8/8]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Fetch, typename Reduction, typename Store, typename T = typename std::enable_if_t< std::is_integral_v< IndexBegin > && std::is_integral_v< IndexEnd > >>

void TNL::Graphs::reduceVerticesWithArgument	(	Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over a given range of vertex indexes while returning also the position of the edge of interest with automatic identity deduction.

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices where the reduction will be performed.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.

Parameters

graph	The graph on which the reduction will be performed.
begin	The beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
end	The end of the interval [ begin, end ) of vertices where the reduction will be performed.
fetch	Lambda function for fetching data. See For Non-Const Graphs.
reduction	Function object for reduction operation with argument. See Reduction Function Objects.
store	Lambda function for storing results. See Store With Argument (Position Tracking).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

reduceVerticesWithArgumentIf() [1/4]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Condition, typename Fetch, typename Reduction, typename Store, typename FetchValue = decltype( std::declval< Fetch >()( 0, 0, std::declval< typename Graph::RealType >() ) )>

Graph::IndexType TNL::Graphs::reduceVerticesWithArgumentIf	(	const Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Condition &&	condition,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		const FetchValue &	identity,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over a given range of vertex indexes based on a condition while returning also the position of the edge of interest (const version).

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices where the reduction will be performed.
Condition	The type of the lambda function used for the condition check.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.
FetchValue	The type returned by the Fetch lambda function.

Parameters

graph	The graph on which the reduction will be performed.
begin	The beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
end	The end of the interval [ begin, end ) of vertices where the reduction will be performed.
condition	Lambda function for vertex condition checking. See Condition Check.
fetch	Lambda function for fetching data. See For Const Graphs.
reduction	Function object for reduction with argument tracking. See Reduction Function Objects.
store	Lambda function for storing results with position tracking. See Store With Argument (Position Tracking).
identity	The identity edge for the reduction operation.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Returns

The number of processed vertices, i.e. vertices for which the condition was true.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesWithArgumentIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Find minimum edge weight and target vertex for vertices in range [1, 4) with degree >= 2.
    */
   TNL::Containers::Vector< float, Device > vertexMinWeights( 5, -1 );
   TNL::Containers::Vector< float, Device > compressedVertexMinWeights( 5 );
   TNL::Containers::Vector< int, Device > vertexMinTargets( 5, -1 );
   TNL::Containers::Vector< int, Device > compressedVertexMinTargets( 5 );
   auto vertexMinWeights_view = vertexMinWeights.getView();
   auto compressedVertexMinWeights_view = compressedVertexMinWeights.getView();
   auto vertexMinTargets_view = vertexMinTargets.getView();
   auto compressedVertexMinTargets_view = compressedVertexMinTargets.getView();
 
   auto condition = [ = ] __cuda_callable__( int vertexIdx ) -> bool
   {
      return graph.getVertexDegree( vertexIdx ) >= 2;
   };
 
   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };
 
   auto store =
      [ = ] __cuda_callable__(
         int indexOfVertexIdx, int vertexIdx, int localIdx, int targetIdx, float minWeight, bool isolatedVertex ) mutable
   {
      compressedVertexMinWeights_view[ indexOfVertexIdx ] = minWeight;
      vertexMinWeights_view[ vertexIdx ] = minWeight;
      if( ! isolatedVertex ) {
         compressedVertexMinTargets_view[ indexOfVertexIdx ] = targetIdx;
         vertexMinTargets_view[ vertexIdx ] = targetIdx;
      }
   };
 
   int traversedVertexCount =
      TNL::Graphs::reduceVerticesWithArgumentIf( graph, 1, 4, condition, fetch, TNL::MinWithArg{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Number of traversed vertices: " << traversedVertexCount << '\n';
   std::cout << "Minimum edge weight for vertices 1-3 with degree >= 2:" << vertexMinWeights << '\n';
   std::cout << "Target vertex for minimum edge:" << vertexMinTargets << '\n';
   std::cout << "Compressed minimum weights:" << compressedVertexMinWeights.getView( 0, traversedVertexCount ) << '\n';
   std::cout << "Compressed minimum targets:" << compressedVertexMinTargets.getView( 0, traversedVertexCount ) << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesWithArgumentIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesWithArgumentIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of traversed vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Target vertex for minimum edge:[ -1, 2, -1, 0, -1 ]
Compressed minimum weights:[ 30, 70 ]
Compressed minimum targets:[ 2, 0 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of traversed vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Target vertex for minimum edge:[ -1, 2, -1, 0, -1 ]
Compressed minimum weights:[ 30, 70 ]
Compressed minimum targets:[ 2, 0 ]

reduceVerticesWithArgumentIf() [2/4]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Condition, typename Fetch, typename Reduction, typename Store>

Graph::IndexType TNL::Graphs::reduceVerticesWithArgumentIf	(	const Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Condition &&	condition,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over a given range of vertex indexes based on a condition while returning also the position of the edge of interest with automatic identity deduction (const version).

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices where the reduction will be performed.
Condition	The type of the lambda function used for the condition check.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.

Parameters

graph	The graph on which the reduction will be performed.
begin	The beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
end	The end of the interval [ begin, end ) of vertices where the reduction will be performed.
condition	Lambda function for vertex condition checking. See Condition Check.
fetch	Lambda function for fetching data. See For Const Graphs.
reduction	Function object for reduction with argument tracking. See Reduction Function Objects.
store	Lambda function for storing results with position tracking. See Store With Argument (Position Tracking).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Returns

The number of processed vertices, i.e. vertices for which the condition was true.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesWithArgumentIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Find minimum edge weight and target vertex for vertices in range [1, 4) with degree >= 2.
    */
   TNL::Containers::Vector< float, Device > vertexMinWeights( 5, -1 );
   TNL::Containers::Vector< float, Device > compressedVertexMinWeights( 5 );
   TNL::Containers::Vector< int, Device > vertexMinTargets( 5, -1 );
   TNL::Containers::Vector< int, Device > compressedVertexMinTargets( 5 );
   auto vertexMinWeights_view = vertexMinWeights.getView();
   auto compressedVertexMinWeights_view = compressedVertexMinWeights.getView();
   auto vertexMinTargets_view = vertexMinTargets.getView();
   auto compressedVertexMinTargets_view = compressedVertexMinTargets.getView();
 
   auto condition = [ = ] __cuda_callable__( int vertexIdx ) -> bool
   {
      return graph.getVertexDegree( vertexIdx ) >= 2;
   };
 
   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };
 
   auto store =
      [ = ] __cuda_callable__(
         int indexOfVertexIdx, int vertexIdx, int localIdx, int targetIdx, float minWeight, bool isolatedVertex ) mutable
   {
      compressedVertexMinWeights_view[ indexOfVertexIdx ] = minWeight;
      vertexMinWeights_view[ vertexIdx ] = minWeight;
      if( ! isolatedVertex ) {
         compressedVertexMinTargets_view[ indexOfVertexIdx ] = targetIdx;
         vertexMinTargets_view[ vertexIdx ] = targetIdx;
      }
   };
 
   int traversedVertexCount =
      TNL::Graphs::reduceVerticesWithArgumentIf( graph, 1, 4, condition, fetch, TNL::MinWithArg{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Number of traversed vertices: " << traversedVertexCount << '\n';
   std::cout << "Minimum edge weight for vertices 1-3 with degree >= 2:" << vertexMinWeights << '\n';
   std::cout << "Target vertex for minimum edge:" << vertexMinTargets << '\n';
   std::cout << "Compressed minimum weights:" << compressedVertexMinWeights.getView( 0, traversedVertexCount ) << '\n';
   std::cout << "Compressed minimum targets:" << compressedVertexMinTargets.getView( 0, traversedVertexCount ) << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesWithArgumentIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesWithArgumentIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of traversed vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Target vertex for minimum edge:[ -1, 2, -1, 0, -1 ]
Compressed minimum weights:[ 30, 70 ]
Compressed minimum targets:[ 2, 0 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of traversed vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Target vertex for minimum edge:[ -1, 2, -1, 0, -1 ]
Compressed minimum weights:[ 30, 70 ]
Compressed minimum targets:[ 2, 0 ]

reduceVerticesWithArgumentIf() [3/4]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Condition, typename Fetch, typename Reduction, typename Store, typename FetchValue = decltype( std::declval< Fetch >()( 0, 0, std::declval< typename Graph::RealType >() ) )>

Graph::IndexType TNL::Graphs::reduceVerticesWithArgumentIf	(	Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Condition &&	condition,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		const FetchValue &	identity,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over a given range of vertex indexes based on a condition while returning also the position of the edge of interest.

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices where the reduction will be performed.
Condition	The type of the lambda function used for the condition check.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.
FetchValue	The type returned by the Fetch lambda function.

Parameters

graph	The graph on which the reduction will be performed.
begin	The beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
end	The end of the interval [ begin, end ) of vertices where the reduction will be performed.
condition	Lambda function for vertex condition checking. See Condition Check.
fetch	Lambda function for fetching data. See For Non-Const Graphs.
reduction	Function object for reduction with argument tracking. See Reduction Function Objects.
store	Lambda function for storing results with position tracking. See Store With Argument (Position Tracking).
identity	The identity edge for the reduction operation.
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Returns

The number of processed vertices, i.e. vertices for which the condition was true.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesWithArgumentIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Find minimum edge weight and target vertex for vertices in range [1, 4) with degree >= 2.
    */
   TNL::Containers::Vector< float, Device > vertexMinWeights( 5, -1 );
   TNL::Containers::Vector< float, Device > compressedVertexMinWeights( 5 );
   TNL::Containers::Vector< int, Device > vertexMinTargets( 5, -1 );
   TNL::Containers::Vector< int, Device > compressedVertexMinTargets( 5 );
   auto vertexMinWeights_view = vertexMinWeights.getView();
   auto compressedVertexMinWeights_view = compressedVertexMinWeights.getView();
   auto vertexMinTargets_view = vertexMinTargets.getView();
   auto compressedVertexMinTargets_view = compressedVertexMinTargets.getView();
 
   auto condition = [ = ] __cuda_callable__( int vertexIdx ) -> bool
   {
      return graph.getVertexDegree( vertexIdx ) >= 2;
   };
 
   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };
 
   auto store =
      [ = ] __cuda_callable__(
         int indexOfVertexIdx, int vertexIdx, int localIdx, int targetIdx, float minWeight, bool isolatedVertex ) mutable
   {
      compressedVertexMinWeights_view[ indexOfVertexIdx ] = minWeight;
      vertexMinWeights_view[ vertexIdx ] = minWeight;
      if( ! isolatedVertex ) {
         compressedVertexMinTargets_view[ indexOfVertexIdx ] = targetIdx;
         vertexMinTargets_view[ vertexIdx ] = targetIdx;
      }
   };
 
   int traversedVertexCount =
      TNL::Graphs::reduceVerticesWithArgumentIf( graph, 1, 4, condition, fetch, TNL::MinWithArg{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Number of traversed vertices: " << traversedVertexCount << '\n';
   std::cout << "Minimum edge weight for vertices 1-3 with degree >= 2:" << vertexMinWeights << '\n';
   std::cout << "Target vertex for minimum edge:" << vertexMinTargets << '\n';
   std::cout << "Compressed minimum weights:" << compressedVertexMinWeights.getView( 0, traversedVertexCount ) << '\n';
   std::cout << "Compressed minimum targets:" << compressedVertexMinTargets.getView( 0, traversedVertexCount ) << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesWithArgumentIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesWithArgumentIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of traversed vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Target vertex for minimum edge:[ -1, 2, -1, 0, -1 ]
Compressed minimum weights:[ 30, 70 ]
Compressed minimum targets:[ 2, 0 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of traversed vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Target vertex for minimum edge:[ -1, 2, -1, 0, -1 ]
Compressed minimum weights:[ 30, 70 ]
Compressed minimum targets:[ 2, 0 ]

reduceVerticesWithArgumentIf() [4/4]

template<typename Graph, typename IndexBegin, typename IndexEnd, typename Condition, typename Fetch, typename Reduction, typename Store>

Graph::IndexType TNL::Graphs::reduceVerticesWithArgumentIf	(	Graph &	graph,
		IndexBegin	begin,
		IndexEnd	end,
		Condition &&	condition,
		Fetch &&	fetch,
		Reduction &&	reduction,
		Store &&	store,
		TNL::Algorithms::Segments::LaunchConfiguration	launchConfig = TNL::Algorithms::Segments::LaunchConfiguration() )

Performs parallel reduction within each graph vertex over a given range of vertex indexes based on a condition while returning also the position of the edge of interest with automatic identity deduction.

See also: Overview of Graph Reduction Functions

Template Parameters

Graph	The type of the graph.
IndexBegin	The type of the index defining the beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
IndexEnd	The type of the index defining the end of the interval [ begin, end ) of vertices where the reduction will be performed.
Condition	The type of the lambda function used for the condition check.
Fetch	The type of the lambda function used for data fetching.
Reduction	The type of the function object defining the reduction operation.
Store	The type of the lambda function used for storing results from individual vertices.

Parameters

graph	The graph on which the reduction will be performed.
begin	The beginning of the interval [ begin, end ) of vertices where the reduction will be performed.
end	The end of the interval [ begin, end ) of vertices where the reduction will be performed.
condition	Lambda function for vertex condition checking. See Condition Check.
fetch	Lambda function for fetching data. See For Non-Const Graphs.
reduction	Function object for reduction with argument tracking. See Reduction Function Objects.
store	Lambda function for storing results with position tracking. See Store With Argument (Position Tracking).
launchConfig	The configuration of the launch - see TNL::Algorithms::Segments::LaunchConfiguration.

Returns

The number of processed vertices, i.e. vertices for which the condition was true.

Example

#include <iostream>
#include <TNL/Graphs/Graph.h>
#include <TNL/Graphs/reduce.h>
#include <TNL/Devices/Host.h>
#include <TNL/Devices/Cuda.h>
#include <TNL/Containers/Vector.h>
 
template< typename Device >
void
reduceVerticesWithArgumentIfExample()
{
   /***
    * Create a directed graph with 5 vertices.
    */
   using GraphType = TNL::Graphs::Graph< float, Device, int, TNL::Graphs::DirectedGraph >;
   // clang-format off
   GraphType graph( 5, // number of vertices
        {  // definition of edges with weights
          { 0, 1, 10.0 }, { 0, 2, 20.0 },
                          { 1, 2, 30.0 }, { 1, 3, 40.0 }, { 1, 4, 50.0 },
                                          { 2, 3, 60.0 },
          { 3, 0, 70.0 },                                 { 3, 4, 80.0 } } );
   // clang-format on
 
   /***
    * Print the graph.
    */
   std::cout << "Graph:\n" << graph << '\n';

   /***
    * Find minimum edge weight and target vertex for vertices in range [1, 4) with degree >= 2.
    */
   TNL::Containers::Vector< float, Device > vertexMinWeights( 5, -1 );
   TNL::Containers::Vector< float, Device > compressedVertexMinWeights( 5 );
   TNL::Containers::Vector< int, Device > vertexMinTargets( 5, -1 );
   TNL::Containers::Vector< int, Device > compressedVertexMinTargets( 5 );
   auto vertexMinWeights_view = vertexMinWeights.getView();
   auto compressedVertexMinWeights_view = compressedVertexMinWeights.getView();
   auto vertexMinTargets_view = vertexMinTargets.getView();
   auto compressedVertexMinTargets_view = compressedVertexMinTargets.getView();
 
   auto condition = [ = ] __cuda_callable__( int vertexIdx ) -> bool
   {
      return graph.getVertexDegree( vertexIdx ) >= 2;
   };
 
   auto fetch = [] __cuda_callable__( int sourceIdx, int targetIdx, const float& weight ) -> float
   {
      return weight;
   };
 
   auto store =
      [ = ] __cuda_callable__(
         int indexOfVertexIdx, int vertexIdx, int localIdx, int targetIdx, float minWeight, bool isolatedVertex ) mutable
   {
      compressedVertexMinWeights_view[ indexOfVertexIdx ] = minWeight;
      vertexMinWeights_view[ vertexIdx ] = minWeight;
      if( ! isolatedVertex ) {
         compressedVertexMinTargets_view[ indexOfVertexIdx ] = targetIdx;
         vertexMinTargets_view[ vertexIdx ] = targetIdx;
      }
   };
 
   int traversedVertexCount =
      TNL::Graphs::reduceVerticesWithArgumentIf( graph, 1, 4, condition, fetch, TNL::MinWithArg{}, store );
 
   /***
    * Print results.
    */
   std::cout << "Number of traversed vertices: " << traversedVertexCount << '\n';
   std::cout << "Minimum edge weight for vertices 1-3 with degree >= 2:" << vertexMinWeights << '\n';
   std::cout << "Target vertex for minimum edge:" << vertexMinTargets << '\n';
   std::cout << "Compressed minimum weights:" << compressedVertexMinWeights.getView( 0, traversedVertexCount ) << '\n';
   std::cout << "Compressed minimum targets:" << compressedVertexMinTargets.getView( 0, traversedVertexCount ) << '\n';
}
 
int
main( int argc, char* argv[] )
{
   std::cout << "Running on host:\n";
   reduceVerticesWithArgumentIfExample< TNL::Devices::Host >();
 
#ifdef __CUDACC__
   std::cout << "Running on CUDA device:\n";
   reduceVerticesWithArgumentIfExample< TNL::Devices::Cuda >();
#endif
 
   return EXIT_SUCCESS;
}

Output

Running on host:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of traversed vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Target vertex for minimum edge:[ -1, 2, -1, 0, -1 ]
Compressed minimum weights:[ 30, 70 ]
Compressed minimum targets:[ 2, 0 ]
Running on CUDA device:
Graph:
Row: 0 ->     1:10      2:20  
Row: 1 ->     2:30      3:40      4:50  
Row: 2 ->     3:60  
Row: 3 ->     0:70      4:80  
Row: 4 -> 
 
Number of traversed vertices: 2
Minimum edge weight for vertices 1-3 with degree >= 2:[ -1, 30, -1, 70, -1 ]
Target vertex for minimum edge:[ -1, 2, -1, 0, -1 ]
Compressed minimum weights:[ 30, 70 ]
Compressed minimum targets:[ 2, 0 ]