Abdelrahman Said
258 lines
10 KiB
C
258 lines
10 KiB
C
/*
|
|
igraph library.
|
|
Copyright (C) 2024 The igraph development team <igraph@igraph.org>
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "igraph_reachability.h"
|
|
|
|
#include "igraph_adjlist.h"
|
|
#include "igraph_bitset_list.h"
|
|
#include "igraph_components.h"
|
|
#include "igraph_constructors.h"
|
|
#include "igraph_interface.h"
|
|
|
|
|
|
/**
|
|
* \ingroup structural
|
|
* \function igraph_reachability
|
|
* \brief Calculates which vertices are reachable from each vertex in the graph.
|
|
*
|
|
* The resulting list will contain one bitset for each strongly connected component.
|
|
* The bitset for component i will have its j-th bit set, if vertex j is reachable
|
|
* from some vertex in component i in 0 or more steps.
|
|
* In particular, a vertex is always reachable from itself.
|
|
*
|
|
* \param graph The graph object to analyze.
|
|
* \param membership Pointer to an integer vector. For every vertex,
|
|
* the ID of its component is given. The vector will be resized as needed.
|
|
* This parameter must not be \c NULL.
|
|
* \param csize Pointer to an integer vector or \c NULL. For every component, it
|
|
* gives its size (vertex count), the order being defined by the component
|
|
* IDs. The vector will be resized as needed.
|
|
* \param no_of_components Pointer to an integer or \c NULL. The number of
|
|
* components will be stored here.
|
|
* \param reach A list of bitsets representing the result. It will be resized
|
|
* as needed. <code>reach[membership[u]][v]</code> is set to \c true if
|
|
* vertex \c v is reachable from vertex \c u.
|
|
* \param mode In directed graphs, controls the treatment of edge directions.
|
|
* Ignored in undirected graphs. With \c IGRAPH_OUT, reachability is computed
|
|
* by traversing edges along their direction. With \c IGRAPH_IN, edges are
|
|
* traversed opposite to their direction. With \c IGRAPH_ALL, edge directions
|
|
* are ignored and the graph is treated as undirected.
|
|
* \return Error code:
|
|
* \c IGRAPH_ENOMEM if there is not enough memory
|
|
* to perform the operation.
|
|
*
|
|
* \sa \ref igraph_connected_components() to find the connnected components
|
|
* of a graph; \ref igraph_count_reachable() to count how many vertices
|
|
* are reachable from each vertex; \ref igraph_subcomponent() to find
|
|
* which vertices are rechable from a single vertex.
|
|
*
|
|
* Time complexity: O(|C||V|/w + |V| + |E|), where
|
|
* |C| is the number of strongly connected components (at most |V|),
|
|
* |V| is the number of vertices, and
|
|
* |E| is the number of edges respectively,
|
|
* and w is the bit width of \type igraph_int_t, typically the
|
|
* word size of the machine (32 or 64).
|
|
*/
|
|
|
|
igraph_error_t igraph_reachability(
|
|
const igraph_t *graph,
|
|
igraph_vector_int_t *membership,
|
|
igraph_vector_int_t *csize,
|
|
igraph_int_t *no_of_components,
|
|
igraph_bitset_list_t *reach,
|
|
igraph_neimode_t mode) {
|
|
|
|
const igraph_int_t no_of_nodes = igraph_vcount(graph);
|
|
igraph_int_t no_of_comps;
|
|
igraph_adjlist_t adjlist, dag;
|
|
|
|
if (mode != IGRAPH_ALL && mode != IGRAPH_OUT && mode != IGRAPH_IN) {
|
|
IGRAPH_ERROR("Invalid mode for reachability.", IGRAPH_EINVMODE);
|
|
}
|
|
|
|
if (! igraph_is_directed(graph)) {
|
|
mode = IGRAPH_ALL;
|
|
}
|
|
|
|
IGRAPH_CHECK(igraph_connected_components(graph,
|
|
membership, csize, &no_of_comps,
|
|
mode == IGRAPH_ALL ? IGRAPH_WEAK : IGRAPH_STRONG));
|
|
|
|
if (no_of_components) {
|
|
*no_of_components = no_of_comps;
|
|
}
|
|
|
|
IGRAPH_CHECK(igraph_bitset_list_resize(reach, no_of_comps));
|
|
|
|
for (igraph_int_t comp = 0; comp < no_of_comps; comp++) {
|
|
IGRAPH_CHECK(igraph_bitset_resize(igraph_bitset_list_get_ptr(reach, comp), no_of_nodes));
|
|
}
|
|
for (igraph_int_t v = 0; v < no_of_nodes; v++) {
|
|
IGRAPH_BIT_SET(*igraph_bitset_list_get_ptr(reach, VECTOR(*membership)[v]), v);
|
|
}
|
|
|
|
if (mode == IGRAPH_ALL) {
|
|
return IGRAPH_SUCCESS;
|
|
}
|
|
|
|
IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, mode, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE));
|
|
IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);
|
|
|
|
IGRAPH_CHECK(igraph_adjlist_init_empty(&dag, no_of_comps));
|
|
IGRAPH_FINALLY(igraph_adjlist_destroy, &dag);
|
|
|
|
for (igraph_int_t v = 0; v < no_of_nodes; v++) {
|
|
const igraph_vector_int_t *neighbours = igraph_adjlist_get(&adjlist, v);
|
|
igraph_vector_int_t *dag_neighbours = igraph_adjlist_get(&dag, VECTOR(*membership)[v]);
|
|
const igraph_int_t n = igraph_vector_int_size(neighbours);
|
|
for (igraph_int_t i = 0; i < n; i++) {
|
|
igraph_int_t w = VECTOR(*neighbours)[i];
|
|
if (VECTOR(*membership)[v] != VECTOR(*membership)[w]) {
|
|
IGRAPH_CHECK(igraph_vector_int_push_back(dag_neighbours, VECTOR(*membership)[w]));
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Iterate through strongly connected components in reverser topological order,
|
|
* exploiting the fact that they are indexed in topological order. */
|
|
for (igraph_int_t i = 0; i < no_of_comps; i++) {
|
|
const igraph_int_t comp = mode == IGRAPH_IN ? i : no_of_comps - i - 1;
|
|
const igraph_vector_int_t *dag_neighbours = igraph_adjlist_get(&dag, comp);
|
|
igraph_bitset_t *from_bitset = igraph_bitset_list_get_ptr(reach, comp);
|
|
const igraph_int_t n = igraph_vector_int_size(dag_neighbours);
|
|
for (igraph_int_t j = 0; j < n; j++) {
|
|
const igraph_bitset_t *to_bitset = igraph_bitset_list_get_ptr(reach, VECTOR(*dag_neighbours)[j]);
|
|
igraph_bitset_or(from_bitset, from_bitset, to_bitset);
|
|
}
|
|
}
|
|
|
|
igraph_adjlist_destroy(&adjlist);
|
|
igraph_adjlist_destroy(&dag);
|
|
IGRAPH_FINALLY_CLEAN(2);
|
|
|
|
return IGRAPH_SUCCESS;
|
|
}
|
|
|
|
|
|
/**
|
|
* \ingroup structural
|
|
* \function igraph_count_reachable
|
|
* \brief The number of vertices reachable from each vertex in the graph.
|
|
*
|
|
* \param graph The graph object to analyze.
|
|
* \param counts Integer vector. <code>counts[v]</code> will store the number
|
|
* of vertices reachable from vertex \c v, including \c v itself.
|
|
* \param mode In directed graphs, controls the treatment of edge directions.
|
|
* Ignored in undirected graphs. With \c IGRAPH_OUT, reachability is computed
|
|
* by traversing edges along their direction. With \c IGRAPH_IN, edges are
|
|
* traversed opposite to their direction. With \c IGRAPH_ALL, edge directions
|
|
* are ignored and the graph is treated as undirected.
|
|
* \return Error code:
|
|
* \c IGRAPH_ENOMEM if there is not enough memory
|
|
* to perform the operation.
|
|
*
|
|
* \sa \ref igraph_connected_components(), \ref igraph_transitive_closure()
|
|
*
|
|
* Time complexity: O(|C||V|/w + |V| + |E|), where
|
|
* |C| is the number of strongly connected components (at most |V|),
|
|
* |V| is the number of vertices, and
|
|
* |E| is the number of edges respectively,
|
|
* and w is the bit width of \type igraph_int_t, typically the
|
|
* word size of the machine (32 or 64).
|
|
*/
|
|
|
|
igraph_error_t igraph_count_reachable(const igraph_t *graph,
|
|
igraph_vector_int_t *counts,
|
|
igraph_neimode_t mode) {
|
|
|
|
igraph_vector_int_t membership;
|
|
igraph_int_t no_of_nodes = igraph_vcount(graph);
|
|
igraph_bitset_list_t reach;
|
|
|
|
IGRAPH_VECTOR_INT_INIT_FINALLY(&membership, 0);
|
|
IGRAPH_BITSET_LIST_INIT_FINALLY(&reach, 0);
|
|
|
|
IGRAPH_CHECK(igraph_reachability(graph, &membership, NULL, NULL, &reach, mode));
|
|
|
|
IGRAPH_CHECK(igraph_vector_int_resize(counts, igraph_vcount(graph)));
|
|
for (igraph_int_t i = 0; i < no_of_nodes; i++) {
|
|
VECTOR(*counts)[i] = igraph_bitset_popcount(igraph_bitset_list_get_ptr(&reach, VECTOR(membership)[i]));
|
|
}
|
|
|
|
igraph_bitset_list_destroy(&reach);
|
|
igraph_vector_int_destroy(&membership);
|
|
IGRAPH_FINALLY_CLEAN(2);
|
|
|
|
return IGRAPH_SUCCESS;
|
|
}
|
|
|
|
|
|
/**
|
|
* \ingroup structural
|
|
* \function igraph_transitive_closure
|
|
* \brief Computes the transitive closure of a graph.
|
|
*
|
|
* The resulting graph will have an edge from vertex \c i to vertex \c j
|
|
* if \c j is reachable from \c i.
|
|
*
|
|
* \param graph The graph object to analyze.
|
|
* \param closure The resulting graph representing the transitive closure.
|
|
* \return Error code:
|
|
* \c IGRAPH_ENOMEM if there is not enough memory
|
|
* to perform the operation.
|
|
*
|
|
* \sa \ref igraph_connected_components(), \ref igraph_count_reachable()
|
|
*
|
|
* Time complexity: O(|V|^2 + |E|), where
|
|
* |V| is the number of vertices, and
|
|
* |E| is the number of edges, respectively.
|
|
*/
|
|
igraph_error_t igraph_transitive_closure(const igraph_t *graph, igraph_t *closure) {
|
|
const igraph_int_t no_of_nodes = igraph_vcount(graph);
|
|
const igraph_bool_t directed = igraph_is_directed(graph);
|
|
igraph_vector_int_t membership, edges;
|
|
igraph_bitset_list_t reach;
|
|
|
|
IGRAPH_VECTOR_INT_INIT_FINALLY(&membership, 0);
|
|
IGRAPH_BITSET_LIST_INIT_FINALLY(&reach, 0);
|
|
|
|
IGRAPH_CHECK(igraph_reachability(graph, &membership, NULL, NULL, &reach, IGRAPH_OUT));
|
|
|
|
IGRAPH_VECTOR_INT_INIT_FINALLY(&edges, 0);
|
|
for (igraph_int_t u = 0; u < no_of_nodes; u++) {
|
|
const igraph_bitset_t *row = igraph_bitset_list_get_ptr(&reach, VECTOR(membership)[u]);
|
|
for (igraph_int_t v = directed ? 0 : u + 1; v < no_of_nodes; v++) {
|
|
if (u != v && IGRAPH_BIT_TEST(*row, v)) {
|
|
IGRAPH_CHECK(igraph_vector_int_push_back(&edges, u));
|
|
IGRAPH_CHECK(igraph_vector_int_push_back(&edges, v));
|
|
}
|
|
}
|
|
}
|
|
|
|
igraph_bitset_list_destroy(&reach);
|
|
igraph_vector_int_destroy(&membership);
|
|
IGRAPH_FINALLY_CLEAN(2);
|
|
|
|
IGRAPH_CHECK(igraph_create(closure, &edges, no_of_nodes, directed));
|
|
|
|
igraph_vector_int_destroy(&edges);
|
|
IGRAPH_FINALLY_CLEAN(1);
|
|
|
|
return IGRAPH_SUCCESS;
|
|
}
|