LLVMFuzzerTestOneInput: 29| 1.17k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) { 30| 1.17k| igraph_t graph; 31| 1.17k| igraph_vector_int_t edges; 32| | 33| 1.17k| igraph_set_error_handler(igraph_error_handler_ignore); 34| 1.17k| igraph_set_warning_handler(igraph_warning_handler_ignore); 35| | 36| | /* We work with small, up-to 16-vertex graphs, as the algorithms 37| | * tested here can be slow. Each byte is interpreted as an edge. 38| | * A simple graph can have at most 120 edges, but we allow up 39| | * to 240, as the fuzzer usually generates multigraphs. */ 40| | 41| 1.17k| if (Size > 240) { ------------------ | Branch (41:9): [True: 14, False: 1.15k] ------------------ 42| 14| return 0; 43| 14| } 44| | 45| 1.15k| check_err(igraph_vector_int_init(&edges, 2*Size)); 46| 1.15k| size_t j = 0; 47| 24.0k| for (size_t i=0; i < Size; ++i) { ------------------ | Branch (47:22): [True: 22.8k, False: 1.15k] ------------------ 48| 22.8k| VECTOR(edges)[j++] = Data[i] / 16; ------------------ | | 69| 22.8k|#define VECTOR(v) ((v).stor_begin) ------------------ 49| 22.8k| VECTOR(edges)[j++] = Data[i] % 16; ------------------ | | 69| 22.8k|#define VECTOR(v) ((v).stor_begin) ------------------ 50| 22.8k| } 51| | 52| 1.15k| if (! igraph_create(&graph, &edges, 0, IGRAPH_UNDIRECTED)) { ------------------ | Branch (52:9): [True: 1.15k, False: 0] ------------------ 53| 1.15k| { 54| 1.15k| igraph_vector_int_list_t separators; 55| 1.15k| check_err(igraph_vector_int_list_init(&separators, 0)); 56| 1.15k| check_err(igraph_all_minimal_st_separators(&graph, &separators)); 57| 1.15k| igraph_vector_int_list_destroy(&separators); 58| 1.15k| } 59| | 60| 1.15k| { 61| 1.15k| igraph_vector_int_list_t separators; 62| 1.15k| check_err(igraph_vector_int_list_init(&separators, 0)); 63| 1.15k| check_err(igraph_minimum_size_separators(&graph, &separators)); 64| 1.15k| igraph_vector_int_list_destroy(&separators); 65| 1.15k| } 66| | 67| 1.15k| igraph_destroy(&graph); 68| 1.15k| } 69| | 70| 1.15k| igraph_vector_int_destroy(&edges); 71| | 72| 1.15k| IGRAPH_ASSERT(IGRAPH_FINALLY_STACK_EMPTY); ------------------ | | 1107| 1.15k| do { \ | | 1108| 1.15k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 1.15k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.15k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | ------------------ | | | | 468| 0|# define IGRAPH_FILE_BASENAME __FILE__ | | ------------------ | | 1110| 0| } \ | | 1111| 1.15k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 73| | 74| 1.15k| return 0; // Non-zero return values are reserved for future use. 75| 1.15k|} _Z9check_erri: 24| 5.79k|inline void check_err(int err) { 25| 5.79k| if (err) ------------------ | Branch (25:9): [True: 0, False: 5.79k] ------------------ 26| 0| abort(); 27| 5.79k|} igraph_connected_components: 95| 5.36k|) { 96| 5.36k| if (mode == IGRAPH_WEAK || !igraph_is_directed(graph)) { ------------------ | Branch (96:9): [True: 0, False: 5.36k] | Branch (96:32): [True: 0, False: 5.36k] ------------------ 97| 0| return igraph_i_connected_components_weak(graph, membership, csize, no); 98| 5.36k| } else if (mode == IGRAPH_STRONG) { ------------------ | Branch (98:16): [True: 5.36k, False: 0] ------------------ 99| 5.36k| return igraph_i_connected_components_strong(graph, membership, csize, no); 100| 5.36k| } 101| | 102| 0| IGRAPH_ERROR("Cannot calculate connected components.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 103| 0|} igraph_is_connected: 398| 1.15k| igraph_connectedness_t mode) { 399| | 400| 1.15k| igraph_cached_property_t prop; 401| 1.15k| igraph_integer_t no_of_nodes = igraph_vcount(graph); 402| 1.15k| igraph_integer_t no; 403| | 404| 1.15k| if (!igraph_is_directed(graph)) { ------------------ | Branch (404:9): [True: 1.15k, False: 0] ------------------ 405| 1.15k| mode = IGRAPH_WEAK; 406| 1.15k| } 407| | 408| 1.15k| switch (mode) { 409| 1.15k| case IGRAPH_WEAK: ------------------ | Branch (409:9): [True: 1.15k, False: 0] ------------------ 410| 1.15k| prop = IGRAPH_PROP_IS_WEAKLY_CONNECTED; 411| 1.15k| break; 412| | 413| 0| case IGRAPH_STRONG: ------------------ | Branch (413:9): [True: 0, False: 1.15k] ------------------ 414| 0| prop = IGRAPH_PROP_IS_STRONGLY_CONNECTED; 415| 0| break; 416| | 417| 0| default: ------------------ | Branch (417:9): [True: 0, False: 1.15k] ------------------ 418| 0| IGRAPH_ERROR("Invalid connectedness mode.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 419| 1.15k| } 420| | 421| 1.15k| IGRAPH_RETURN_IF_CACHED_BOOL(graph, prop, res); ------------------ | | 85| 1.15k| do { \ | | 86| 1.15k| if (igraph_i_property_cache_has((graphptr), (prop))) { \ | | ------------------ | | | Branch (86:13): [True: 0, False: 1.15k] | | ------------------ | | 87| 0| *(resptr) = igraph_i_property_cache_get_bool((graphptr), (prop)); \ | | 88| 0| return IGRAPH_SUCCESS; \ | | 89| 0| } \ | | 90| 1.15k| } while (0) | | ------------------ | | | Branch (90:14): [Folded - Ignored] | | ------------------ ------------------ 422| | 423| 1.15k| if (no_of_nodes == 0) { ------------------ | Branch (423:9): [True: 0, False: 1.15k] ------------------ 424| | /* Changed in igraph 0.9; see https://github.com/igraph/igraph/issues/1539 425| | * for the reasoning behind the change */ 426| 0| *res = false; 427| 1.15k| } else if (no_of_nodes == 1) { ------------------ | Branch (427:16): [True: 8, False: 1.15k] ------------------ 428| 8| *res = true; 429| 1.15k| } else if (mode == IGRAPH_WEAK) { ------------------ | Branch (429:16): [True: 1.15k, False: 0] ------------------ 430| 1.15k| IGRAPH_CHECK(igraph_is_connected_weak(graph, res)); ------------------ | | 752| 1.15k| do { \ | | 753| 1.15k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.15k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.15k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.15k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.15k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 431| 1.15k| } else { /* mode == IGRAPH_STRONG */ 432| | /* A strongly connected graph has at least as many edges as vertices, 433| | * except for the singleton graph, which is handled above. */ 434| 0| if (igraph_ecount(graph) < no_of_nodes) { ------------------ | Branch (434:13): [True: 0, False: 0] ------------------ 435| 0| *res = false; 436| 0| } else { 437| 0| IGRAPH_CHECK(igraph_i_connected_components_strong(graph, NULL, NULL, &no)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 438| 0| *res = (no == 1); 439| 0| } 440| 0| } 441| | 442| | /* Cache updates are done in igraph_i_connected_components_strong() and 443| | * igraph_is_connected_weak() because those might be called from other 444| | * places and we want to make use of the caching if so */ 445| | 446| 1.15k| return IGRAPH_SUCCESS; 447| 1.15k|} igraph_articulation_points: 948| 201|igraph_error_t igraph_articulation_points(const igraph_t *graph, igraph_vector_int_t *res) { 949| | 950| 201| return igraph_biconnected_components(graph, NULL, NULL, NULL, NULL, res); 951| 201|} igraph_biconnected_components: 1013| 201| igraph_vector_int_t *articulation_points) { 1014| | 1015| 201| igraph_integer_t no_of_nodes = igraph_vcount(graph); 1016| 201| igraph_vector_int_t nextptr; 1017| 201| igraph_vector_int_t num, low; 1018| 201| igraph_vector_bool_t found; 1019| 201| igraph_vector_int_t *adjedges; 1020| 201| igraph_stack_int_t path; 1021| 201| igraph_stack_int_t edgestack; 1022| 201| igraph_inclist_t inclist; 1023| 201| igraph_integer_t counter, rootdfs = 0; 1024| 201| igraph_vector_int_t vertex_added; 1025| 201| igraph_integer_t comps = 0; 1026| 201| igraph_vector_int_list_t *mycomponents = components, vcomponents; 1027| | 1028| 201| IGRAPH_VECTOR_INT_INIT_FINALLY(&nextptr, no_of_nodes); ------------------ | | 124| 201| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 201| do { \ | | | | 753| 201| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 201| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 201| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 201] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 201| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 201| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 201| do { \ | | | | 696| 201| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 201| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 201| * incorrect destructor function with the pointer */ \ | | | | 699| 201| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 201| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 201| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 1029| 201| IGRAPH_VECTOR_INT_INIT_FINALLY(&num, no_of_nodes); ------------------ | | 124| 201| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 201| do { \ | | | | 753| 201| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 201| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 201| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 201] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 201| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 201| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 201| do { \ | | | | 696| 201| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 201| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 201| * incorrect destructor function with the pointer */ \ | | | | 699| 201| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 201| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 201| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 1030| 201| IGRAPH_VECTOR_INT_INIT_FINALLY(&low, no_of_nodes); ------------------ | | 124| 201| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 201| do { \ | | | | 753| 201| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 201| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 201| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 201] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 201| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 201| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 201| do { \ | | | | 696| 201| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 201| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 201| * incorrect destructor function with the pointer */ \ | | | | 699| 201| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 201| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 201| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 1031| 201| IGRAPH_VECTOR_BOOL_INIT_FINALLY(&found, no_of_nodes); ------------------ | | 114| 201| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \ | | ------------------ | | | | 752| 201| do { \ | | | | 753| 201| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 201| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 201| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 201] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 201| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 115| 201| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0) | | ------------------ | | | | 695| 201| do { \ | | | | 696| 201| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 201| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 201| * incorrect destructor function with the pointer */ \ | | | | 699| 201| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 201| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 201| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (115:65): [Folded - Ignored] | | ------------------ ------------------ 1032| | 1033| 201| IGRAPH_STACK_INT_INIT_FINALLY(&path, 100); ------------------ | | 66| 201| do { IGRAPH_CHECK(igraph_stack_int_init(s, capacity)); \ | | ------------------ | | | | 752| 201| do { \ | | | | 753| 201| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 201| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 201| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 201] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 201| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 67| 201| IGRAPH_FINALLY(igraph_stack_int_destroy, s); } while (0) | | ------------------ | | | | 695| 201| do { \ | | | | 696| 201| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 201| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 201| * incorrect destructor function with the pointer */ \ | | | | 699| 201| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 201| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 201| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (67:63): [Folded - Ignored] | | ------------------ ------------------ 1034| 201| IGRAPH_STACK_INT_INIT_FINALLY(&edgestack, 100); ------------------ | | 66| 201| do { IGRAPH_CHECK(igraph_stack_int_init(s, capacity)); \ | | ------------------ | | | | 752| 201| do { \ | | | | 753| 201| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 201| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 201| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 201] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 201| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 67| 201| IGRAPH_FINALLY(igraph_stack_int_destroy, s); } while (0) | | ------------------ | | | | 695| 201| do { \ | | | | 696| 201| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 201| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 201| * incorrect destructor function with the pointer */ \ | | | | 699| 201| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 201| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 201| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (67:63): [Folded - Ignored] | | ------------------ ------------------ 1035| | 1036| 201| IGRAPH_CHECK(igraph_inclist_init(graph, &inclist, IGRAPH_ALL, IGRAPH_LOOPS_TWICE)); ------------------ | | 752| 201| do { \ | | 753| 201| igraph_error_t igraph_i_ret = (expr); \ | | 754| 201| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 201| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 201] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 201| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1037| 201| IGRAPH_FINALLY(igraph_inclist_destroy, &inclist); ------------------ | | 695| 201| do { \ | | 696| 201| /* the following branch makes the compiler check the compatibility of \ | | 697| 201| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 201| * incorrect destructor function with the pointer */ \ | | 699| 201| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 201| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 201| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 1038| | 1039| 201| IGRAPH_VECTOR_INT_INIT_FINALLY(&vertex_added, no_of_nodes); ------------------ | | 124| 201| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 201| do { \ | | | | 753| 201| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 201| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 201| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 201] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 201| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 201| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 201| do { \ | | | | 696| 201| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 201| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 201| * incorrect destructor function with the pointer */ \ | | | | 699| 201| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 201| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 201| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 1040| | 1041| 201| if (no) { ------------------ | Branch (1041:9): [True: 0, False: 201] ------------------ 1042| 0| *no = 0; 1043| 0| } 1044| 201| if (tree_edges) { ------------------ | Branch (1044:9): [True: 0, False: 201] ------------------ 1045| 0| igraph_vector_int_list_clear(tree_edges); 1046| 0| } 1047| 201| if (components) { ------------------ | Branch (1047:9): [True: 0, False: 201] ------------------ 1048| 0| igraph_vector_int_list_clear(components); 1049| 0| } 1050| 201| if (component_edges) { ------------------ | Branch (1050:9): [True: 0, False: 201] ------------------ 1051| 0| igraph_vector_int_list_clear(component_edges); 1052| 0| } 1053| 201| if (articulation_points) { ------------------ | Branch (1053:9): [True: 201, False: 0] ------------------ 1054| 201| igraph_vector_int_clear(articulation_points); 1055| 201| } 1056| 201| if (component_edges && !components) { ------------------ | Branch (1056:9): [True: 0, False: 201] | Branch (1056:28): [True: 0, False: 0] ------------------ 1057| 0| mycomponents = &vcomponents; 1058| 0| IGRAPH_VECTOR_INT_LIST_INIT_FINALLY(mycomponents, 0); ------------------ | | 68| 0| do { IGRAPH_CHECK(igraph_vector_int_list_init(v, size)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 69| 0| IGRAPH_FINALLY(igraph_vector_int_list_destroy, v); } while (0) | | ------------------ | | | | 695| 0| do { \ | | | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 0| * incorrect destructor function with the pointer */ \ | | | | 699| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 0| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (69:69): [Folded - Ignored] | | ------------------ ------------------ 1059| 0| } 1060| | 1061| 1.44k| for (igraph_integer_t i = 0; i < no_of_nodes; i++) { ------------------ | Branch (1061:34): [True: 1.24k, False: 201] ------------------ 1062| | 1063| 1.24k| if (VECTOR(low)[i] != 0) { ------------------ | | 69| 1.24k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1063:13): [True: 1.03k, False: 201] ------------------ 1064| 1.03k| continue; /* already visited */ 1065| 1.03k| } 1066| | 1067| 201| IGRAPH_ALLOW_INTERRUPTION(); ------------------ | | 47| 201| do { \ | | 48| 201| if (igraph_i_interruption_handler) { \ | | ------------------ | | | Branch (48:13): [True: 0, False: 201] | | ------------------ | | 49| 0| if (igraph_allow_interruption(NULL) != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (49:17): [True: 0, False: 0] | | ------------------ | | 50| 0| return IGRAPH_INTERRUPTED; \ | | 51| 0| } \ | | 52| 0| } \ | | 53| 201| } while (0) | | ------------------ | | | Branch (53:14): [Folded - Ignored] | | ------------------ ------------------ 1068| | 1069| 201| IGRAPH_CHECK(igraph_stack_int_push(&path, i)); ------------------ | | 752| 201| do { \ | | 753| 201| igraph_error_t igraph_i_ret = (expr); \ | | 754| 201| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 201| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 201] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 201| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1070| 201| counter = 1; 1071| 201| rootdfs = 0; 1072| 201| VECTOR(low)[i] = VECTOR(num)[i] = counter++; ------------------ | | 69| 201|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(low)[i] = VECTOR(num)[i] = counter++; ------------------ | | 69| 201|#define VECTOR(v) ((v).stor_begin) ------------------ 1073| 10.5k| while (!igraph_stack_int_empty(&path)) { ------------------ | Branch (1073:16): [True: 10.3k, False: 201] ------------------ 1074| 10.3k| igraph_integer_t n; 1075| 10.3k| igraph_integer_t act = igraph_stack_int_top(&path); 1076| 10.3k| igraph_integer_t actnext = VECTOR(nextptr)[act]; ------------------ | | 69| 10.3k|#define VECTOR(v) ((v).stor_begin) ------------------ 1077| | 1078| 10.3k| adjedges = igraph_inclist_get(&inclist, act); ------------------ | | 106| 10.3k|#define igraph_inclist_get(il,no) (&(il)->incs[(igraph_integer_t)(no)]) ------------------ 1079| 10.3k| n = igraph_vector_int_size(adjedges); 1080| 10.3k| if (actnext < n) { ------------------ | Branch (1080:17): [True: 9.10k, False: 1.24k] ------------------ 1081| | /* Step down (maybe) */ 1082| 9.10k| igraph_integer_t edge = VECTOR(*adjedges)[actnext]; ------------------ | | 69| 9.10k|#define VECTOR(v) ((v).stor_begin) ------------------ 1083| 9.10k| igraph_integer_t nei = IGRAPH_OTHER(graph, edge, act); ------------------ | | 134| 9.10k| ((igraph_integer_t)(IGRAPH_TO(graph,(eid))==(vid) ? IGRAPH_FROM((graph),(eid)) : IGRAPH_TO((graph),(eid)))) | | ------------------ | | | | 116| 9.10k|#define IGRAPH_TO(graph,eid) ((igraph_integer_t)(VECTOR((graph)->to) [(igraph_integer_t)(eid)])) | | | | ------------------ | | | | | | 69| 9.10k|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | ------------------ | | ((igraph_integer_t)(IGRAPH_TO(graph,(eid))==(vid) ? IGRAPH_FROM((graph),(eid)) : IGRAPH_TO((graph),(eid)))) | | ------------------ | | | | 103| 6.46k|#define IGRAPH_FROM(graph,eid) ((igraph_integer_t)(VECTOR((graph)->from)[(igraph_integer_t)(eid)])) | | | | ------------------ | | | | | | 69| 6.46k|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | ------------------ | | ((igraph_integer_t)(IGRAPH_TO(graph,(eid))==(vid) ? IGRAPH_FROM((graph),(eid)) : IGRAPH_TO((graph),(eid)))) | | ------------------ | | | | 116| 2.63k|#define IGRAPH_TO(graph,eid) ((igraph_integer_t)(VECTOR((graph)->to) [(igraph_integer_t)(eid)])) | | | | ------------------ | | | | | | 69| 2.63k|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | ------------------ | | | Branch (134:25): [True: 6.46k, False: 2.63k] | | ------------------ ------------------ 1084| 9.10k| if (VECTOR(low)[nei] == 0) { ------------------ | | 69| 9.10k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1084:21): [True: 1.03k, False: 8.06k] ------------------ 1085| 1.03k| if (act == i) { ------------------ | Branch (1085:25): [True: 286, False: 753] ------------------ 1086| 286| rootdfs++; 1087| 286| } 1088| 1.03k| IGRAPH_CHECK(igraph_stack_int_push(&edgestack, edge)); ------------------ | | 752| 1.03k| do { \ | | 753| 1.03k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.03k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.03k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.03k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.03k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1089| 1.03k| IGRAPH_CHECK(igraph_stack_int_push(&path, nei)); ------------------ | | 752| 1.03k| do { \ | | 753| 1.03k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.03k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.03k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.03k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.03k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1090| 1.03k| VECTOR(low)[nei] = VECTOR(num)[nei] = counter++; ------------------ | | 69| 1.03k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(low)[nei] = VECTOR(num)[nei] = counter++; ------------------ | | 69| 1.03k|#define VECTOR(v) ((v).stor_begin) ------------------ 1091| 8.06k| } else { 1092| | /* Update low value if needed */ 1093| 8.06k| if (VECTOR(num)[nei] < VECTOR(low)[act]) { ------------------ | | 69| 8.06k|#define VECTOR(v) ((v).stor_begin) ------------------ if (VECTOR(num)[nei] < VECTOR(low)[act]) { ------------------ | | 69| 8.06k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1093:25): [True: 1.04k, False: 7.02k] ------------------ 1094| 1.04k| VECTOR(low)[act] = VECTOR(num)[nei]; ------------------ | | 69| 1.04k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(low)[act] = VECTOR(num)[nei]; ------------------ | | 69| 1.04k|#define VECTOR(v) ((v).stor_begin) ------------------ 1095| 1.04k| } 1096| 8.06k| } 1097| 9.10k| VECTOR(nextptr)[act] += 1; ------------------ | | 69| 9.10k|#define VECTOR(v) ((v).stor_begin) ------------------ 1098| 9.10k| } else { 1099| | /* Step up */ 1100| 1.24k| igraph_stack_int_pop(&path); 1101| 1.24k| if (!igraph_stack_int_empty(&path)) { ------------------ | Branch (1101:21): [True: 1.03k, False: 201] ------------------ 1102| 1.03k| igraph_integer_t prev = igraph_stack_int_top(&path); 1103| | /* Update LOW value if needed */ 1104| 1.03k| if (VECTOR(low)[act] < VECTOR(low)[prev]) { ------------------ | | 69| 1.03k|#define VECTOR(v) ((v).stor_begin) ------------------ if (VECTOR(low)[act] < VECTOR(low)[prev]) { ------------------ | | 69| 1.03k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1104:25): [True: 200, False: 839] ------------------ 1105| 200| VECTOR(low)[prev] = VECTOR(low)[act]; ------------------ | | 69| 200|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(low)[prev] = VECTOR(low)[act]; ------------------ | | 69| 200|#define VECTOR(v) ((v).stor_begin) ------------------ 1106| 200| } 1107| | /* Check for articulation point */ 1108| 1.03k| if (VECTOR(low)[act] >= VECTOR(num)[prev]) { ------------------ | | 69| 1.03k|#define VECTOR(v) ((v).stor_begin) ------------------ if (VECTOR(low)[act] >= VECTOR(num)[prev]) { ------------------ | | 69| 1.03k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1108:25): [True: 658, False: 381] ------------------ 1109| 658| if (articulation_points && !VECTOR(found)[prev] ------------------ | | 69| 658|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1109:29): [True: 658, False: 0] | Branch (1109:52): [True: 604, False: 54] ------------------ 1110| 658| && prev != i /* the root */) { ------------------ | Branch (1110:32): [True: 318, False: 286] ------------------ 1111| 318| IGRAPH_CHECK(igraph_vector_int_push_back(articulation_points, prev)); ------------------ | | 752| 318| do { \ | | 753| 318| igraph_error_t igraph_i_ret = (expr); \ | | 754| 318| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 318| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 318] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 318| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1112| 318| VECTOR(found)[prev] = 1; ------------------ | | 69| 318|#define VECTOR(v) ((v).stor_begin) ------------------ 1113| 318| } 1114| 658| if (no) { ------------------ | Branch (1114:29): [True: 0, False: 658] ------------------ 1115| 0| *no += 1; 1116| 0| } 1117| | 1118| | /*------------------------------------*/ 1119| | /* Record the biconnected component just found */ 1120| 658| if (tree_edges || mycomponents) { ------------------ | Branch (1120:29): [True: 0, False: 658] | Branch (1120:43): [True: 0, False: 658] ------------------ 1121| 0| igraph_vector_int_t *v, *v2; 1122| 0| comps++; 1123| 0| if (tree_edges) { ------------------ | Branch (1123:33): [True: 0, False: 0] ------------------ 1124| 0| IGRAPH_CHECK(igraph_vector_int_list_push_back_new(tree_edges, &v)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1125| 0| } 1126| 0| if (mycomponents) { ------------------ | Branch (1126:33): [True: 0, False: 0] ------------------ 1127| 0| IGRAPH_CHECK(igraph_vector_int_list_push_back_new(mycomponents, &v2)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1128| 0| } 1129| | 1130| 0| while (!igraph_stack_int_empty(&edgestack)) { ------------------ | Branch (1130:36): [True: 0, False: 0] ------------------ 1131| 0| igraph_integer_t e = igraph_stack_int_pop(&edgestack); 1132| 0| igraph_integer_t from = IGRAPH_FROM(graph, e); ------------------ | | 103| 0|#define IGRAPH_FROM(graph,eid) ((igraph_integer_t)(VECTOR((graph)->from)[(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1133| 0| igraph_integer_t to = IGRAPH_TO(graph, e); ------------------ | | 116| 0|#define IGRAPH_TO(graph,eid) ((igraph_integer_t)(VECTOR((graph)->to) [(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1134| 0| if (tree_edges) { ------------------ | Branch (1134:37): [True: 0, False: 0] ------------------ 1135| 0| IGRAPH_CHECK(igraph_vector_int_push_back(v, e)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1136| 0| } 1137| 0| if (mycomponents) { ------------------ | Branch (1137:37): [True: 0, False: 0] ------------------ 1138| 0| if (VECTOR(vertex_added)[from] != comps) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1138:41): [True: 0, False: 0] ------------------ 1139| 0| VECTOR(vertex_added)[from] = comps; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 1140| 0| IGRAPH_CHECK(igraph_vector_int_push_back(v2, from)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1141| 0| } 1142| 0| if (VECTOR(vertex_added)[to] != comps) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1142:41): [True: 0, False: 0] ------------------ 1143| 0| VECTOR(vertex_added)[to] = comps; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 1144| 0| IGRAPH_CHECK(igraph_vector_int_push_back(v2, to)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1145| 0| } 1146| 0| } 1147| 0| if (from == prev || to == prev) { ------------------ | Branch (1147:37): [True: 0, False: 0] | Branch (1147:53): [True: 0, False: 0] ------------------ 1148| 0| break; 1149| 0| } 1150| 0| } 1151| | 1152| 0| if (component_edges) { ------------------ | Branch (1152:33): [True: 0, False: 0] ------------------ 1153| 0| igraph_vector_int_t *nodes = igraph_vector_int_list_get_ptr(mycomponents, comps - 1); 1154| 0| igraph_integer_t ii, no_vert = igraph_vector_int_size(nodes); 1155| 0| igraph_vector_int_t *vv; 1156| | 1157| 0| IGRAPH_CHECK(igraph_vector_int_list_push_back_new(component_edges, &vv)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1158| 0| for (ii = 0; ii < no_vert; ii++) { ------------------ | Branch (1158:46): [True: 0, False: 0] ------------------ 1159| 0| igraph_integer_t vert = VECTOR(*nodes)[ii]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 1160| 0| igraph_vector_int_t *edges = igraph_inclist_get(&inclist, ------------------ | | 106| 0|#define igraph_inclist_get(il,no) (&(il)->incs[(igraph_integer_t)(no)]) ------------------ 1161| 0| vert); 1162| 0| igraph_integer_t j, nn = igraph_vector_int_size(edges); 1163| 0| for (j = 0; j < nn; j++) { ------------------ | Branch (1163:49): [True: 0, False: 0] ------------------ 1164| 0| igraph_integer_t e = VECTOR(*edges)[j]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 1165| 0| igraph_integer_t nei = IGRAPH_OTHER(graph, e, vert); ------------------ | | 134| 0| ((igraph_integer_t)(IGRAPH_TO(graph,(eid))==(vid) ? IGRAPH_FROM((graph),(eid)) : IGRAPH_TO((graph),(eid)))) | | ------------------ | | | | 116| 0|#define IGRAPH_TO(graph,eid) ((igraph_integer_t)(VECTOR((graph)->to) [(igraph_integer_t)(eid)])) | | | | ------------------ | | | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | ------------------ | | ((igraph_integer_t)(IGRAPH_TO(graph,(eid))==(vid) ? IGRAPH_FROM((graph),(eid)) : IGRAPH_TO((graph),(eid)))) | | ------------------ | | | | 103| 0|#define IGRAPH_FROM(graph,eid) ((igraph_integer_t)(VECTOR((graph)->from)[(igraph_integer_t)(eid)])) | | | | ------------------ | | | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | ------------------ | | ((igraph_integer_t)(IGRAPH_TO(graph,(eid))==(vid) ? IGRAPH_FROM((graph),(eid)) : IGRAPH_TO((graph),(eid)))) | | ------------------ | | | | 116| 0|#define IGRAPH_TO(graph,eid) ((igraph_integer_t)(VECTOR((graph)->to) [(igraph_integer_t)(eid)])) | | | | ------------------ | | | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | ------------------ | | | Branch (134:25): [True: 0, False: 0] | | ------------------ ------------------ 1166| 0| if (VECTOR(vertex_added)[nei] == comps && nei < vert) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1166:45): [True: 0, False: 0] | Branch (1166:83): [True: 0, False: 0] ------------------ 1167| 0| IGRAPH_CHECK(igraph_vector_int_push_back(vv, e)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1168| 0| } 1169| 0| } 1170| 0| } 1171| 0| } 1172| 0| } /* record component if requested */ 1173| | /*------------------------------------*/ 1174| | 1175| 658| } 1176| 1.03k| } /* !igraph_stack_int_empty(&path) */ 1177| 1.24k| } 1178| | 1179| 10.3k| } /* !igraph_stack_int_empty(&path) */ 1180| | 1181| 201| if (articulation_points && rootdfs >= 2) { ------------------ | Branch (1181:13): [True: 201, False: 0] | Branch (1181:36): [True: 53, False: 148] ------------------ 1182| 53| IGRAPH_CHECK(igraph_vector_int_push_back(articulation_points, i)); ------------------ | | 752| 53| do { \ | | 753| 53| igraph_error_t igraph_i_ret = (expr); \ | | 754| 53| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 53| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 53] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 53| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1183| 53| } 1184| | 1185| 201| } /* i < no_of_nodes */ 1186| | 1187| 201| if (mycomponents != components) { ------------------ | Branch (1187:9): [True: 0, False: 201] ------------------ 1188| 0| igraph_vector_int_list_destroy(mycomponents); 1189| 0| IGRAPH_FINALLY_CLEAN(1); 1190| 0| } 1191| | 1192| 201| igraph_vector_int_destroy(&vertex_added); 1193| 201| igraph_inclist_destroy(&inclist); 1194| 201| igraph_stack_int_destroy(&edgestack); 1195| 201| igraph_stack_int_destroy(&path); 1196| 201| igraph_vector_bool_destroy(&found); 1197| 201| igraph_vector_int_destroy(&low); 1198| 201| igraph_vector_int_destroy(&num); 1199| 201| igraph_vector_int_destroy(&nextptr); 1200| 201| IGRAPH_FINALLY_CLEAN(8); 1201| | 1202| 201| return IGRAPH_SUCCESS; 1203| 201|} components.c:igraph_i_connected_components_strong: 194| 5.36k|) { 195| 5.36k| igraph_integer_t no_of_nodes = igraph_vcount(graph); 196| 5.36k| igraph_vector_int_t next_nei = IGRAPH_VECTOR_NULL; ------------------ | | 104| 5.36k| #define IGRAPH_VECTOR_NULL { 0,0,0 } ------------------ 197| | 198| 5.36k| igraph_integer_t i, n, num_seen; 199| 5.36k| igraph_dqueue_int_t q = IGRAPH_DQUEUE_NULL; ------------------ | | 61| 5.36k|#define IGRAPH_DQUEUE_NULL { 0,0,0,0 } ------------------ 200| | 201| 5.36k| igraph_integer_t no_of_clusters = 0; 202| 5.36k| igraph_integer_t act_cluster_size; 203| | 204| 5.36k| igraph_vector_int_t out = IGRAPH_VECTOR_NULL; ------------------ | | 104| 5.36k| #define IGRAPH_VECTOR_NULL { 0,0,0 } ------------------ 205| 5.36k| const igraph_vector_int_t* tmp; 206| | 207| 5.36k| igraph_adjlist_t adjlist; 208| | 209| | /* The result */ 210| | 211| 5.36k| IGRAPH_VECTOR_INT_INIT_FINALLY(&next_nei, no_of_nodes); ------------------ | | 124| 5.36k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 5.36k| do { \ | | | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 5.36k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 5.36k| do { \ | | | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | | | 699| 5.36k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 212| 5.36k| IGRAPH_VECTOR_INT_INIT_FINALLY(&out, 0); ------------------ | | 124| 5.36k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 5.36k| do { \ | | | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 5.36k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 5.36k| do { \ | | | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | | | 699| 5.36k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 213| 5.36k| IGRAPH_DQUEUE_INT_INIT_FINALLY(&q, 100); ------------------ | | 66| 5.36k| do { IGRAPH_CHECK(igraph_dqueue_int_init(q, capacity)); \ | | ------------------ | | | | 752| 5.36k| do { \ | | | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 67| 5.36k| IGRAPH_FINALLY(igraph_dqueue_int_destroy, q); } while (0) | | ------------------ | | | | 695| 5.36k| do { \ | | | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | | | 699| 5.36k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (67:64): [Folded - Ignored] | | ------------------ ------------------ 214| | 215| 5.36k| if (membership) { ------------------ | Branch (215:9): [True: 5.36k, False: 0] ------------------ 216| 5.36k| IGRAPH_CHECK(igraph_vector_int_resize(membership, no_of_nodes)); ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 217| 5.36k| } 218| 5.36k| IGRAPH_CHECK(igraph_vector_int_reserve(&out, no_of_nodes)); ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 219| | 220| 5.36k| igraph_vector_int_null(&out); 221| 5.36k| if (csize) { ------------------ | Branch (221:9): [True: 0, False: 5.36k] ------------------ 222| 0| igraph_vector_int_clear(csize); 223| 0| } 224| | 225| 5.36k| IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_OUT, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE)); ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 226| 5.36k| IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist); ------------------ | | 695| 5.36k| do { \ | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | 699| 5.36k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 5.36k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 227| | 228| 5.36k| num_seen = 0; 229| 133k| for (i = 0; i < no_of_nodes; i++) { ------------------ | Branch (229:17): [True: 127k, False: 5.36k] ------------------ 230| 127k| IGRAPH_ALLOW_INTERRUPTION(); ------------------ | | 47| 127k| do { \ | | 48| 127k| if (igraph_i_interruption_handler) { \ | | ------------------ | | | Branch (48:13): [True: 0, False: 127k] | | ------------------ | | 49| 0| if (igraph_allow_interruption(NULL) != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (49:17): [True: 0, False: 0] | | ------------------ | | 50| 0| return IGRAPH_INTERRUPTED; \ | | 51| 0| } \ | | 52| 0| } \ | | 53| 127k| } while (0) | | ------------------ | | | Branch (53:14): [Folded - Ignored] | | ------------------ ------------------ 231| | 232| 127k| tmp = igraph_adjlist_get(&adjlist, i); ------------------ | | 77| 127k|#define igraph_adjlist_get(al,no) (&(al)->adjs[(igraph_integer_t)(no)]) ------------------ 233| 127k| if (VECTOR(next_nei)[i] > igraph_vector_int_size(tmp)) { ------------------ | | 69| 127k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (233:13): [True: 121k, False: 6.02k] ------------------ 234| 121k| continue; 235| 121k| } 236| | 237| 6.02k| IGRAPH_CHECK(igraph_dqueue_int_push(&q, i)); ------------------ | | 752| 6.02k| do { \ | | 753| 6.02k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 6.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 6.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 6.02k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 6.02k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 238| 627k| while (!igraph_dqueue_int_empty(&q)) { ------------------ | Branch (238:16): [True: 621k, False: 6.02k] ------------------ 239| 621k| igraph_integer_t act_node = igraph_dqueue_int_back(&q); 240| 621k| tmp = igraph_adjlist_get(&adjlist, act_node); ------------------ | | 77| 621k|#define igraph_adjlist_get(al,no) (&(al)->adjs[(igraph_integer_t)(no)]) ------------------ 241| 621k| if (VECTOR(next_nei)[act_node] == 0) { ------------------ | | 69| 621k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (241:17): [True: 127k, False: 493k] ------------------ 242| | /* this is the first time we've met this vertex */ 243| 127k| VECTOR(next_nei)[act_node]++; ------------------ | | 69| 127k|#define VECTOR(v) ((v).stor_begin) ------------------ 244| 493k| } else if (VECTOR(next_nei)[act_node] <= igraph_vector_int_size(tmp)) { ------------------ | | 69| 493k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (244:24): [True: 365k, False: 127k] ------------------ 245| | /* we've already met this vertex but it has more children */ 246| 365k| igraph_integer_t neighbor = VECTOR(*tmp)[VECTOR(next_nei)[act_node] - 1]; ------------------ | | 69| 365k|#define VECTOR(v) ((v).stor_begin) ------------------ igraph_integer_t neighbor = VECTOR(*tmp)[VECTOR(next_nei)[act_node] - 1]; ------------------ | | 69| 365k|#define VECTOR(v) ((v).stor_begin) ------------------ 247| 365k| if (VECTOR(next_nei)[neighbor] == 0) { ------------------ | | 69| 365k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (247:21): [True: 121k, False: 244k] ------------------ 248| 121k| IGRAPH_CHECK(igraph_dqueue_int_push(&q, neighbor)); ------------------ | | 752| 121k| do { \ | | 753| 121k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 121k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 121k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 121k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 121k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 249| 121k| } 250| 365k| VECTOR(next_nei)[act_node]++; ------------------ | | 69| 365k|#define VECTOR(v) ((v).stor_begin) ------------------ 251| 365k| } else { 252| | /* we've met this vertex and it has no more children */ 253| 127k| IGRAPH_CHECK(igraph_vector_int_push_back(&out, act_node)); ------------------ | | 752| 127k| do { \ | | 753| 127k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 127k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 127k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 127k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 127k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 254| 127k| igraph_dqueue_int_pop_back(&q); 255| 127k| num_seen++; 256| | 257| 127k| if (num_seen % 10000 == 0) { ------------------ | Branch (257:21): [True: 0, False: 127k] ------------------ 258| | /* time to report progress and allow the user to interrupt */ 259| 0| IGRAPH_PROGRESS("Strongly connected components: ", ------------------ | | 175| 0| do { \ | | 176| 0| if (igraph_progress((message), (percent), (data)) != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (176:13): [True: 0, False: 0] | | ------------------ | | 177| 0| IGRAPH_FINALLY_FREE(); \ | | 178| 0| return IGRAPH_INTERRUPTED; \ | | 179| 0| } \ | | 180| 0| } while (0) | | ------------------ | | | Branch (180:14): [Folded - Ignored] | | ------------------ ------------------ 260| 0| num_seen * 50.0 / no_of_nodes, NULL); 261| 0| IGRAPH_ALLOW_INTERRUPTION(); ------------------ | | 47| 0| do { \ | | 48| 0| if (igraph_i_interruption_handler) { \ | | ------------------ | | | Branch (48:13): [True: 0, False: 0] | | ------------------ | | 49| 0| if (igraph_allow_interruption(NULL) != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (49:17): [True: 0, False: 0] | | ------------------ | | 50| 0| return IGRAPH_INTERRUPTED; \ | | 51| 0| } \ | | 52| 0| } \ | | 53| 0| } while (0) | | ------------------ | | | Branch (53:14): [Folded - Ignored] | | ------------------ ------------------ 262| 0| } 263| 127k| } 264| 621k| } /* while q */ 265| 6.02k| } /* for */ 266| | 267| 5.36k| IGRAPH_PROGRESS("Strongly connected components: ", 50.0, NULL); ------------------ | | 175| 5.36k| do { \ | | 176| 5.36k| if (igraph_progress((message), (percent), (data)) != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (176:13): [True: 0, False: 5.36k] | | ------------------ | | 177| 0| IGRAPH_FINALLY_FREE(); \ | | 178| 0| return IGRAPH_INTERRUPTED; \ | | 179| 0| } \ | | 180| 5.36k| } while (0) | | ------------------ | | | Branch (180:14): [Folded - Ignored] | | ------------------ ------------------ 268| | 269| 5.36k| igraph_adjlist_destroy(&adjlist); 270| 5.36k| IGRAPH_FINALLY_CLEAN(1); 271| | 272| 5.36k| IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_IN, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE)); ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 273| 5.36k| IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist); ------------------ | | 695| 5.36k| do { \ | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | 699| 5.36k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 5.36k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 274| | 275| | /* OK, we've the 'out' values for the nodes, let's use them in 276| | decreasing order with the help of a heap */ 277| | 278| 5.36k| igraph_vector_int_null(&next_nei); /* mark already added vertices */ 279| 5.36k| num_seen = 0; 280| | 281| 133k| while (!igraph_vector_int_empty(&out)) { ------------------ | Branch (281:12): [True: 127k, False: 5.36k] ------------------ 282| 127k| igraph_integer_t grandfather = igraph_vector_int_pop_back(&out); 283| | 284| 127k| if (VECTOR(next_nei)[grandfather] != 0) { ------------------ | | 69| 127k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (284:13): [True: 106k, False: 21.7k] ------------------ 285| 106k| continue; 286| 106k| } 287| 21.7k| VECTOR(next_nei)[grandfather] = 1; ------------------ | | 69| 21.7k|#define VECTOR(v) ((v).stor_begin) ------------------ 288| 21.7k| act_cluster_size = 1; 289| 21.7k| if (membership) { ------------------ | Branch (289:13): [True: 21.7k, False: 0] ------------------ 290| 21.7k| VECTOR(*membership)[grandfather] = no_of_clusters; ------------------ | | 69| 21.7k|#define VECTOR(v) ((v).stor_begin) ------------------ 291| 21.7k| } 292| 21.7k| IGRAPH_CHECK(igraph_dqueue_int_push(&q, grandfather)); ------------------ | | 752| 21.7k| do { \ | | 753| 21.7k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 21.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 21.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 21.7k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 21.7k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 293| | 294| 21.7k| num_seen++; 295| 21.7k| if (num_seen % 10000 == 0) { ------------------ | Branch (295:13): [True: 0, False: 21.7k] ------------------ 296| | /* time to report progress and allow the user to interrupt */ 297| 0| IGRAPH_PROGRESS("Strongly connected components: ", ------------------ | | 175| 0| do { \ | | 176| 0| if (igraph_progress((message), (percent), (data)) != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (176:13): [True: 0, False: 0] | | ------------------ | | 177| 0| IGRAPH_FINALLY_FREE(); \ | | 178| 0| return IGRAPH_INTERRUPTED; \ | | 179| 0| } \ | | 180| 0| } while (0) | | ------------------ | | | Branch (180:14): [Folded - Ignored] | | ------------------ ------------------ 298| 0| 50.0 + num_seen * 50.0 / no_of_nodes, NULL); 299| 0| IGRAPH_ALLOW_INTERRUPTION(); ------------------ | | 47| 0| do { \ | | 48| 0| if (igraph_i_interruption_handler) { \ | | ------------------ | | | Branch (48:13): [True: 0, False: 0] | | ------------------ | | 49| 0| if (igraph_allow_interruption(NULL) != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (49:17): [True: 0, False: 0] | | ------------------ | | 50| 0| return IGRAPH_INTERRUPTED; \ | | 51| 0| } \ | | 52| 0| } \ | | 53| 0| } while (0) | | ------------------ | | | Branch (53:14): [Folded - Ignored] | | ------------------ ------------------ 300| 0| } 301| | 302| 149k| while (!igraph_dqueue_int_empty(&q)) { ------------------ | Branch (302:16): [True: 127k, False: 21.7k] ------------------ 303| 127k| igraph_integer_t act_node = igraph_dqueue_int_pop_back(&q); 304| 127k| tmp = igraph_adjlist_get(&adjlist, act_node); ------------------ | | 77| 127k|#define igraph_adjlist_get(al,no) (&(al)->adjs[(igraph_integer_t)(no)]) ------------------ 305| 127k| n = igraph_vector_int_size(tmp); 306| 493k| for (i = 0; i < n; i++) { ------------------ | Branch (306:25): [True: 365k, False: 127k] ------------------ 307| 365k| igraph_integer_t neighbor = VECTOR(*tmp)[i]; ------------------ | | 69| 365k|#define VECTOR(v) ((v).stor_begin) ------------------ 308| 365k| if (VECTOR(next_nei)[neighbor] != 0) { ------------------ | | 69| 365k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (308:21): [True: 259k, False: 106k] ------------------ 309| 259k| continue; 310| 259k| } 311| 106k| IGRAPH_CHECK(igraph_dqueue_int_push(&q, neighbor)); ------------------ | | 752| 106k| do { \ | | 753| 106k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 106k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 106k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 106k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 106k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 312| 106k| VECTOR(next_nei)[neighbor] = 1; ------------------ | | 69| 106k|#define VECTOR(v) ((v).stor_begin) ------------------ 313| 106k| act_cluster_size++; 314| 106k| if (membership) { ------------------ | Branch (314:21): [True: 106k, False: 0] ------------------ 315| 106k| VECTOR(*membership)[neighbor] = no_of_clusters; ------------------ | | 69| 106k|#define VECTOR(v) ((v).stor_begin) ------------------ 316| 106k| } 317| | 318| 106k| num_seen++; 319| 106k| if (num_seen % 10000 == 0) { ------------------ | Branch (319:21): [True: 0, False: 106k] ------------------ 320| | /* time to report progress and allow the user to interrupt */ 321| 0| IGRAPH_PROGRESS("Strongly connected components: ", ------------------ | | 175| 0| do { \ | | 176| 0| if (igraph_progress((message), (percent), (data)) != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (176:13): [True: 0, False: 0] | | ------------------ | | 177| 0| IGRAPH_FINALLY_FREE(); \ | | 178| 0| return IGRAPH_INTERRUPTED; \ | | 179| 0| } \ | | 180| 0| } while (0) | | ------------------ | | | Branch (180:14): [Folded - Ignored] | | ------------------ ------------------ 322| 0| 50.0 + num_seen * 50.0 / no_of_nodes, NULL); 323| 0| IGRAPH_ALLOW_INTERRUPTION(); ------------------ | | 47| 0| do { \ | | 48| 0| if (igraph_i_interruption_handler) { \ | | ------------------ | | | Branch (48:13): [True: 0, False: 0] | | ------------------ | | 49| 0| if (igraph_allow_interruption(NULL) != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (49:17): [True: 0, False: 0] | | ------------------ | | 50| 0| return IGRAPH_INTERRUPTED; \ | | 51| 0| } \ | | 52| 0| } \ | | 53| 0| } while (0) | | ------------------ | | | Branch (53:14): [Folded - Ignored] | | ------------------ ------------------ 324| 0| } 325| 106k| } 326| 127k| } 327| | 328| 21.7k| no_of_clusters++; 329| 21.7k| if (csize) { ------------------ | Branch (329:13): [True: 0, False: 21.7k] ------------------ 330| 0| IGRAPH_CHECK(igraph_vector_int_push_back(csize, act_cluster_size)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 331| 0| } 332| 21.7k| } 333| | 334| 5.36k| IGRAPH_PROGRESS("Strongly connected components: ", 100.0, NULL); ------------------ | | 175| 5.36k| do { \ | | 176| 5.36k| if (igraph_progress((message), (percent), (data)) != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (176:13): [True: 0, False: 5.36k] | | ------------------ | | 177| 0| IGRAPH_FINALLY_FREE(); \ | | 178| 0| return IGRAPH_INTERRUPTED; \ | | 179| 0| } \ | | 180| 5.36k| } while (0) | | ------------------ | | | Branch (180:14): [Folded - Ignored] | | ------------------ ------------------ 335| | 336| 5.36k| if (no) { ------------------ | Branch (336:9): [True: 5.36k, False: 0] ------------------ 337| 5.36k| *no = no_of_clusters; 338| 5.36k| } 339| | 340| | /* Clean up */ 341| 5.36k| igraph_adjlist_destroy(&adjlist); 342| 5.36k| igraph_vector_int_destroy(&out); 343| 5.36k| igraph_dqueue_int_destroy(&q); 344| 5.36k| igraph_vector_int_destroy(&next_nei); 345| 5.36k| IGRAPH_FINALLY_CLEAN(4); 346| | 347| | /* Update cache */ 348| 5.36k| igraph_i_property_cache_set_bool(graph, IGRAPH_PROP_IS_STRONGLY_CONNECTED, no_of_clusters == 1); 349| 5.36k| if (no_of_clusters == 1) { ------------------ | Branch (349:9): [True: 0, False: 5.36k] ------------------ 350| 0| igraph_i_property_cache_set_bool(graph, IGRAPH_PROP_IS_WEAKLY_CONNECTED, 1); 351| 0| } 352| | 353| 5.36k| return IGRAPH_SUCCESS; 354| 5.36k|} components.c:igraph_is_connected_weak: 449| 1.15k|static igraph_error_t igraph_is_connected_weak(const igraph_t *graph, igraph_bool_t *res) { 450| 1.15k| igraph_integer_t no_of_nodes = igraph_vcount(graph), no_of_edges = igraph_ecount(graph); 451| 1.15k| igraph_integer_t added_count; 452| 1.15k| bool *already_added; 453| 1.15k| igraph_vector_int_t neis = IGRAPH_VECTOR_NULL; ------------------ | | 104| 1.15k| #define IGRAPH_VECTOR_NULL { 0,0,0 } ------------------ 454| 1.15k| igraph_dqueue_int_t q = IGRAPH_DQUEUE_NULL; ------------------ | | 61| 1.15k|#define IGRAPH_DQUEUE_NULL { 0,0,0,0 } ------------------ 455| | 456| | /* By convention, the null graph is not considered connected. 457| | * See https://github.com/igraph/igraph/issues/1538 */ 458| 1.15k| if (no_of_nodes == 0) { ------------------ | Branch (458:9): [True: 0, False: 1.15k] ------------------ 459| 0| *res = false; 460| 0| goto exit; 461| 0| } 462| | 463| | /* A connected graph has at least |V| - 1 edges. */ 464| 1.15k| if (no_of_edges < no_of_nodes - 1) { ------------------ | Branch (464:9): [True: 100, False: 1.05k] ------------------ 465| 100| *res = false; 466| 100| goto exit; 467| 100| } 468| | 469| 1.05k| already_added = IGRAPH_CALLOC(no_of_nodes, bool); ------------------ | | 32| 1.05k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [True: 1.05k, False: 0] | | ------------------ ------------------ 470| 1.05k| IGRAPH_CHECK_OOM(already_added, "Insufficient memory for computing weakly connected components."); ------------------ | | 807| 1.05k| do { \ | | 808| 1.05k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 1.05k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.05k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 1.05k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 471| 1.05k| IGRAPH_FINALLY(igraph_free, already_added); ------------------ | | 695| 1.05k| do { \ | | 696| 1.05k| /* the following branch makes the compiler check the compatibility of \ | | 697| 1.05k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 1.05k| * incorrect destructor function with the pointer */ \ | | 699| 1.05k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 1.05k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 1.05k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 472| | 473| 1.05k| IGRAPH_DQUEUE_INT_INIT_FINALLY(&q, 10); ------------------ | | 66| 1.05k| do { IGRAPH_CHECK(igraph_dqueue_int_init(q, capacity)); \ | | ------------------ | | | | 752| 1.05k| do { \ | | | | 753| 1.05k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 1.05k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 1.05k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 1.05k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 1.05k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 67| 1.05k| IGRAPH_FINALLY(igraph_dqueue_int_destroy, q); } while (0) | | ------------------ | | | | 695| 1.05k| do { \ | | | | 696| 1.05k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 1.05k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 1.05k| * incorrect destructor function with the pointer */ \ | | | | 699| 1.05k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 1.05k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 1.05k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (67:64): [Folded - Ignored] | | ------------------ ------------------ 474| 1.05k| IGRAPH_VECTOR_INT_INIT_FINALLY(&neis, 0); ------------------ | | 124| 1.05k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 1.05k| do { \ | | | | 753| 1.05k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 1.05k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 1.05k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 1.05k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 1.05k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 1.05k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 1.05k| do { \ | | | | 696| 1.05k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 1.05k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 1.05k| * incorrect destructor function with the pointer */ \ | | | | 699| 1.05k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 1.05k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 1.05k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 475| | 476| | /* Try to find at least two clusters */ 477| 1.05k| already_added[0] = true; 478| 1.05k| IGRAPH_CHECK(igraph_dqueue_int_push(&q, 0)); ------------------ | | 752| 1.05k| do { \ | | 753| 1.05k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.05k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.05k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.05k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.05k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 479| | 480| 1.05k| added_count = 1; 481| 7.83k| while ( !igraph_dqueue_int_empty(&q)) { ------------------ | Branch (481:13): [True: 6.78k, False: 1.05k] ------------------ 482| 6.78k| IGRAPH_ALLOW_INTERRUPTION(); ------------------ | | 47| 6.78k| do { \ | | 48| 6.78k| if (igraph_i_interruption_handler) { \ | | ------------------ | | | Branch (48:13): [True: 0, False: 6.78k] | | ------------------ | | 49| 0| if (igraph_allow_interruption(NULL) != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (49:17): [True: 0, False: 0] | | ------------------ | | 50| 0| return IGRAPH_INTERRUPTED; \ | | 51| 0| } \ | | 52| 0| } \ | | 53| 6.78k| } while (0) | | ------------------ | | | Branch (53:14): [Folded - Ignored] | | ------------------ ------------------ 483| | 484| 6.78k| igraph_integer_t actnode = igraph_dqueue_int_pop(&q); 485| | 486| 6.78k| IGRAPH_CHECK(igraph_neighbors(graph, &neis, actnode, IGRAPH_ALL)); ------------------ | | 752| 6.78k| do { \ | | 753| 6.78k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 6.78k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 6.78k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 6.78k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 6.78k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 487| 6.78k| igraph_integer_t nei_count = igraph_vector_int_size(&neis); 488| | 489| 33.8k| for (igraph_integer_t i = 0; i < nei_count; i++) { ------------------ | Branch (489:38): [True: 28.0k, False: 5.86k] ------------------ 490| 28.0k| igraph_integer_t neighbor = VECTOR(neis)[i]; ------------------ | | 69| 28.0k|#define VECTOR(v) ((v).stor_begin) ------------------ 491| 28.0k| if (already_added[neighbor]) { ------------------ | Branch (491:17): [True: 19.2k, False: 8.73k] ------------------ 492| 19.2k| continue; 493| 19.2k| } 494| | 495| 8.73k| IGRAPH_CHECK(igraph_dqueue_int_push(&q, neighbor)); ------------------ | | 752| 8.73k| do { \ | | 753| 8.73k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 8.73k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 8.73k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 8.73k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 8.73k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 496| 8.73k| added_count++; 497| 8.73k| already_added[neighbor] = true; 498| | 499| 8.73k| if (added_count == no_of_nodes) { ------------------ | Branch (499:17): [True: 921, False: 7.81k] ------------------ 500| | /* We have already reached all nodes: the graph is connected. 501| | * We can stop the traversal now. */ 502| 921| igraph_dqueue_int_clear(&q); 503| 921| break; 504| 921| } 505| 8.73k| } 506| 6.78k| } 507| | 508| | /* Connected? */ 509| 1.05k| *res = (added_count == no_of_nodes); 510| | 511| 1.05k| IGRAPH_FREE(already_added); ------------------ | | 35| 1.05k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 512| 1.05k| igraph_dqueue_int_destroy(&q); 513| 1.05k| igraph_vector_int_destroy(&neis); 514| 1.05k| IGRAPH_FINALLY_CLEAN(3); 515| | 516| 1.15k|exit: 517| 1.15k| igraph_i_property_cache_set_bool(graph, IGRAPH_PROP_IS_WEAKLY_CONNECTED, *res); 518| 1.15k| if (igraph_is_directed(graph) && *res == 0) { ------------------ | Branch (518:9): [True: 0, False: 1.15k] | Branch (518:38): [True: 0, False: 0] ------------------ 519| | /* If the graph is not weakly connected, it is not strongly connected 520| | * either so we can also cache that */ 521| 0| igraph_i_property_cache_set_bool(graph, IGRAPH_PROP_IS_STRONGLY_CONNECTED, *res); 522| 0| } 523| | 524| 1.15k| return IGRAPH_SUCCESS; 525| 1.05k|} igraph_is_separator: 150| 709| igraph_bool_t *res) { 151| | 152| 709| igraph_integer_t no_of_nodes = igraph_vcount(graph); 153| 709| igraph_vector_bool_t removed; 154| 709| igraph_dqueue_int_t Q; 155| 709| igraph_vector_int_t neis; 156| 709| igraph_vit_t vit; 157| | 158| 709| IGRAPH_CHECK(igraph_vit_create(graph, candidate, &vit)); ------------------ | | 752| 709| do { \ | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 709] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 709| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 159| 709| IGRAPH_FINALLY(igraph_vit_destroy, &vit); ------------------ | | 695| 709| do { \ | | 696| 709| /* the following branch makes the compiler check the compatibility of \ | | 697| 709| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 709| * incorrect destructor function with the pointer */ \ | | 699| 709| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 709| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 709| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 160| 709| IGRAPH_CHECK(igraph_vector_bool_init(&removed, no_of_nodes)); ------------------ | | 752| 709| do { \ | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 709] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 709| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 161| 709| IGRAPH_FINALLY(igraph_vector_bool_destroy, &removed); ------------------ | | 695| 709| do { \ | | 696| 709| /* the following branch makes the compiler check the compatibility of \ | | 697| 709| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 709| * incorrect destructor function with the pointer */ \ | | 699| 709| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 709| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 709| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 162| 709| IGRAPH_CHECK(igraph_dqueue_int_init(&Q, 100)); ------------------ | | 752| 709| do { \ | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 709] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 709| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 163| 709| IGRAPH_FINALLY(igraph_dqueue_int_destroy, &Q); ------------------ | | 695| 709| do { \ | | 696| 709| /* the following branch makes the compiler check the compatibility of \ | | 697| 709| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 709| * incorrect destructor function with the pointer */ \ | | 699| 709| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 709| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 709| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 164| 709| IGRAPH_VECTOR_INT_INIT_FINALLY(&neis, 0); ------------------ | | 124| 709| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 709| do { \ | | | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 709] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 709| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 709| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 709| do { \ | | | | 696| 709| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 709| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 709| * incorrect destructor function with the pointer */ \ | | | | 699| 709| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 709| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 709| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 165| | 166| 709| IGRAPH_CHECK(igraph_i_is_separator(graph, &vit, -1, res, &removed, ------------------ | | 752| 709| do { \ | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 709] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 709| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 167| 709| &Q, &neis, no_of_nodes)); 168| | 169| 709| igraph_vector_int_destroy(&neis); 170| 709| igraph_dqueue_int_destroy(&Q); 171| 709| igraph_vector_bool_destroy(&removed); 172| 709| igraph_vit_destroy(&vit); 173| 709| IGRAPH_FINALLY_CLEAN(4); 174| | 175| 709| return IGRAPH_SUCCESS; 176| 709|} igraph_all_minimal_st_separators: 427| 1.15k|) { 428| | 429| | /* 430| | * Some notes about the tricks used here. For finding the components 431| | * of the graph after removing some vertices, we do the 432| | * following. First we mark the vertices with the actual mark stamp 433| | * (mark), then run breadth-first search on the graph, but not 434| | * considering the marked vertices. Then we increase the mark. If 435| | * there is integer overflow here, then we zero out the mark and set 436| | * it to one. (We might as well just always zero it out.) 437| | * 438| | * For each separator the vertices are stored in vertex ID order. 439| | * This facilitates the comparison of the separators when we find a 440| | * potential new candidate. 441| | * 442| | * To keep track of which separator we already used as a basis, we 443| | * keep a boolean vector (already_tried). The try_next pointer show 444| | * the next separator to try as a basis. 445| | */ 446| | 447| 1.15k| igraph_integer_t no_of_nodes = igraph_vcount(graph); 448| 1.15k| igraph_vector_int_t leaveout; 449| 1.15k| igraph_vector_bool_t already_tried; 450| 1.15k| igraph_integer_t try_next = 0; 451| 1.15k| igraph_integer_t mark = 1; 452| 1.15k| igraph_integer_t v; 453| | 454| 1.15k| igraph_adjlist_t adjlist; 455| 1.15k| igraph_vector_int_t components; 456| 1.15k| igraph_dqueue_int_t Q; 457| 1.15k| igraph_vector_int_t sorter; 458| | 459| 1.15k| igraph_vector_int_list_clear(separators); 460| | 461| 1.15k| IGRAPH_VECTOR_INT_INIT_FINALLY(&leaveout, no_of_nodes); ------------------ | | 124| 1.15k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 1.15k| do { \ | | | | 753| 1.15k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 1.15k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 1.15k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 1.15k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 1.15k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 1.15k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 1.15k| do { \ | | | | 696| 1.15k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 1.15k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 1.15k| * incorrect destructor function with the pointer */ \ | | | | 699| 1.15k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 1.15k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 1.15k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 462| 1.15k| IGRAPH_CHECK(igraph_vector_bool_init(&already_tried, 0)); ------------------ | | 752| 1.15k| do { \ | | 753| 1.15k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.15k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.15k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.15k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.15k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 463| 1.15k| IGRAPH_FINALLY(igraph_vector_bool_destroy, &already_tried); ------------------ | | 695| 1.15k| do { \ | | 696| 1.15k| /* the following branch makes the compiler check the compatibility of \ | | 697| 1.15k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 1.15k| * incorrect destructor function with the pointer */ \ | | 699| 1.15k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 1.15k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 1.15k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 464| 1.15k| IGRAPH_VECTOR_INT_INIT_FINALLY(&components, 0); ------------------ | | 124| 1.15k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 1.15k| do { \ | | | | 753| 1.15k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 1.15k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 1.15k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 1.15k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 1.15k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 1.15k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 1.15k| do { \ | | | | 696| 1.15k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 1.15k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 1.15k| * incorrect destructor function with the pointer */ \ | | | | 699| 1.15k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 1.15k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 1.15k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 465| 1.15k| IGRAPH_CHECK(igraph_vector_int_reserve(&components, no_of_nodes * 2)); ------------------ | | 752| 1.15k| do { \ | | 753| 1.15k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.15k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.15k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.15k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.15k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 466| 1.15k| IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_ALL, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE)); ------------------ | | 752| 1.15k| do { \ | | 753| 1.15k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.15k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.15k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.15k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.15k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 467| 1.15k| IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist); ------------------ | | 695| 1.15k| do { \ | | 696| 1.15k| /* the following branch makes the compiler check the compatibility of \ | | 697| 1.15k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 1.15k| * incorrect destructor function with the pointer */ \ | | 699| 1.15k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 1.15k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 1.15k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 468| 1.15k| IGRAPH_CHECK(igraph_dqueue_int_init(&Q, 100)); ------------------ | | 752| 1.15k| do { \ | | 753| 1.15k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.15k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.15k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.15k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.15k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 469| 1.15k| IGRAPH_FINALLY(igraph_dqueue_int_destroy, &Q); ------------------ | | 695| 1.15k| do { \ | | 696| 1.15k| /* the following branch makes the compiler check the compatibility of \ | | 697| 1.15k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 1.15k| * incorrect destructor function with the pointer */ \ | | 699| 1.15k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 1.15k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 1.15k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 470| 1.15k| IGRAPH_VECTOR_INT_INIT_FINALLY(&sorter, 0); ------------------ | | 124| 1.15k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 1.15k| do { \ | | | | 753| 1.15k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 1.15k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 1.15k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 1.15k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 1.15k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 1.15k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 1.15k| do { \ | | | | 696| 1.15k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 1.15k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 1.15k| * incorrect destructor function with the pointer */ \ | | | | 699| 1.15k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 1.15k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 1.15k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 471| 1.15k| IGRAPH_CHECK(igraph_vector_int_reserve(&sorter, no_of_nodes)); ------------------ | | 752| 1.15k| do { \ | | 753| 1.15k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.15k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.15k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.15k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.15k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 472| | 473| | /* --------------------------------------------------------------- 474| | * INITIALIZATION, we check whether the neighborhoods of the 475| | * vertices separate the graph. The ones that do will form the 476| | * initial basis. 477| | */ 478| | 479| 12.6k| for (v = 0; v < no_of_nodes; v++) { ------------------ | Branch (479:17): [True: 11.4k, False: 1.15k] ------------------ 480| | 481| | /* Mark v and its neighbors */ 482| 11.4k| igraph_vector_int_t *neis = igraph_adjlist_get(&adjlist, v); ------------------ | | 77| 11.4k|#define igraph_adjlist_get(al,no) (&(al)->adjs[(igraph_integer_t)(no)]) ------------------ 483| 11.4k| igraph_integer_t i, n = igraph_vector_int_size(neis); 484| 11.4k| VECTOR(leaveout)[v] = mark; ------------------ | | 69| 11.4k|#define VECTOR(v) ((v).stor_begin) ------------------ 485| 57.2k| for (i = 0; i < n; i++) { ------------------ | Branch (485:21): [True: 45.7k, False: 11.4k] ------------------ 486| 45.7k| igraph_integer_t nei = VECTOR(*neis)[i]; ------------------ | | 69| 45.7k|#define VECTOR(v) ((v).stor_begin) ------------------ 487| 45.7k| VECTOR(leaveout)[nei] = mark; ------------------ | | 69| 45.7k|#define VECTOR(v) ((v).stor_begin) ------------------ 488| 45.7k| } 489| | 490| | /* Find the components */ 491| 11.4k| IGRAPH_CHECK(igraph_i_connected_components_leaveout( ------------------ | | 752| 11.4k| do { \ | | 753| 11.4k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 11.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 11.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 11.4k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 11.4k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 492| 11.4k| &adjlist, &components, &leaveout, &mark, &Q)); 493| | 494| | /* Store the corresponding separators, N(C) for each component C */ 495| 11.4k| IGRAPH_CHECK(igraph_i_separators_store(separators, &adjlist, &components, ------------------ | | 752| 11.4k| do { \ | | 753| 11.4k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 11.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 11.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 11.4k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 11.4k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 496| 11.4k| &leaveout, &mark, &sorter)); 497| | 498| 11.4k| } 499| | 500| | /* --------------------------------------------------------------- 501| | * GENERATION, we need to use all already found separators as 502| | * basis and see if they generate more separators 503| | */ 504| | 505| 29.1k| while (try_next < igraph_vector_int_list_size(separators)) { ------------------ | Branch (505:12): [True: 27.9k, False: 1.15k] ------------------ 506| | /* copy "basis" out of the vector_list because we are going to 507| | * mutate the vector_list later, and this can potentially invalidate 508| | * the pointer */ 509| 27.9k| igraph_vector_int_t basis = *(igraph_vector_int_list_get_ptr(separators, try_next)); 510| 27.9k| igraph_integer_t b, basislen = igraph_vector_int_size(&basis); 511| 131k| for (b = 0; b < basislen; b++) { ------------------ | Branch (511:21): [True: 103k, False: 27.9k] ------------------ 512| | 513| | /* Remove N(x) U basis */ 514| 103k| igraph_integer_t x = VECTOR(basis)[b]; ------------------ | | 69| 103k|#define VECTOR(v) ((v).stor_begin) ------------------ 515| 103k| igraph_vector_int_t *neis = igraph_adjlist_get(&adjlist, x); ------------------ | | 77| 103k|#define igraph_adjlist_get(al,no) (&(al)->adjs[(igraph_integer_t)(no)]) ------------------ 516| 103k| igraph_integer_t i, n = igraph_vector_int_size(neis); 517| 647k| for (i = 0; i < basislen; i++) { ------------------ | Branch (517:25): [True: 543k, False: 103k] ------------------ 518| 543k| igraph_integer_t sn = VECTOR(basis)[i]; ------------------ | | 69| 543k|#define VECTOR(v) ((v).stor_begin) ------------------ 519| 543k| VECTOR(leaveout)[sn] = mark; ------------------ | | 69| 543k|#define VECTOR(v) ((v).stor_begin) ------------------ 520| 543k| } 521| 658k| for (i = 0; i < n; i++) { ------------------ | Branch (521:25): [True: 554k, False: 103k] ------------------ 522| 554k| igraph_integer_t nei = VECTOR(*neis)[i]; ------------------ | | 69| 554k|#define VECTOR(v) ((v).stor_begin) ------------------ 523| 554k| VECTOR(leaveout)[nei] = mark; ------------------ | | 69| 554k|#define VECTOR(v) ((v).stor_begin) ------------------ 524| 554k| } 525| | 526| | /* Find the components */ 527| 103k| IGRAPH_CHECK(igraph_i_connected_components_leaveout( ------------------ | | 752| 103k| do { \ | | 753| 103k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 103k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 103k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 103k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 103k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 528| 103k| &adjlist, &components, &leaveout, &mark, &Q)); 529| | 530| | /* Store the corresponding separators, N(C) for each component C */ 531| 103k| IGRAPH_CHECK(igraph_i_separators_store(separators, &adjlist, ------------------ | | 752| 103k| do { \ | | 753| 103k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 103k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 103k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 103k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 103k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 532| 103k| &components, &leaveout, &mark, 533| 103k| &sorter)); 534| 103k| } 535| | 536| 27.9k| try_next++; 537| 27.9k| } 538| | 539| | /* --------------------------------------------------------------- */ 540| | 541| 1.15k| igraph_vector_int_destroy(&sorter); 542| 1.15k| igraph_dqueue_int_destroy(&Q); 543| 1.15k| igraph_adjlist_destroy(&adjlist); 544| 1.15k| igraph_vector_int_destroy(&components); 545| 1.15k| igraph_vector_bool_destroy(&already_tried); 546| 1.15k| igraph_vector_int_destroy(&leaveout); 547| 1.15k| IGRAPH_FINALLY_CLEAN(6); 548| | 549| 1.15k| return IGRAPH_SUCCESS; 550| 1.15k|} igraph_minimum_size_separators: 639| 1.15k|) { 640| | 641| 1.15k| igraph_integer_t no_of_nodes = igraph_vcount(graph); 642| 1.15k| igraph_integer_t no_of_edges = igraph_ecount(graph); 643| 1.15k| igraph_integer_t conn; 644| 1.15k| igraph_vector_int_t X; 645| 1.15k| igraph_integer_t i, j, k, n; 646| 1.15k| igraph_bool_t issepX; 647| 1.15k| igraph_t Gbar; 648| 1.15k| igraph_vector_t phi; 649| 1.15k| igraph_t graph_copy; 650| 1.15k| igraph_vector_t capacity; 651| 1.15k| igraph_maxflow_stats_t stats; 652| | 653| 1.15k| if (igraph_is_directed(graph)) { ------------------ | Branch (653:9): [True: 0, False: 1.15k] ------------------ 654| 0| IGRAPH_ERROR("Minimum size separators currently only works on undirected graphs", ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 655| 0| IGRAPH_EINVAL); 656| 0| } 657| | 658| 1.15k| igraph_vector_int_list_clear(separators); 659| | 660| | /* ---------------------------------------------------------------- */ 661| | /* 1 Find the vertex connectivity of 'graph' */ 662| 1.15k| IGRAPH_CHECK(igraph_vertex_connectivity(graph, &conn, /* checks= */ true)); ------------------ | | 752| 1.15k| do { \ | | 753| 1.15k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.15k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.15k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.15k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.15k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 663| 1.15k| k = conn; 664| | 665| | /* Special cases for low connectivity, two exits here! */ 666| 1.15k| if (conn == 0) { ------------------ | Branch (666:9): [True: 237, False: 921] ------------------ 667| | /* Nothing to do */ 668| 237| return IGRAPH_SUCCESS; 669| 921| } else if (conn == 1) { ------------------ | Branch (669:16): [True: 201, False: 720] ------------------ 670| 201| igraph_vector_int_t ap; 671| 201| IGRAPH_VECTOR_INT_INIT_FINALLY(&ap, 0); ------------------ | | 124| 201| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 201| do { \ | | | | 753| 201| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 201| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 201| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 201] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 201| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 201| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 201| do { \ | | | | 696| 201| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 201| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 201| * incorrect destructor function with the pointer */ \ | | | | 699| 201| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 201| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 201| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 672| 201| IGRAPH_CHECK(igraph_articulation_points(graph, &ap)); ------------------ | | 752| 201| do { \ | | 753| 201| igraph_error_t igraph_i_ret = (expr); \ | | 754| 201| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 201| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 201] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 201| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 673| 201| n = igraph_vector_int_size(&ap); 674| 201| IGRAPH_CHECK(igraph_vector_int_list_resize(separators, n)); ------------------ | | 752| 201| do { \ | | 753| 201| igraph_error_t igraph_i_ret = (expr); \ | | 754| 201| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 201| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 201] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 201| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 675| 572| for (i = 0; i < n; i++) { ------------------ | Branch (675:21): [True: 371, False: 201] ------------------ 676| 371| igraph_vector_int_t *v = igraph_vector_int_list_get_ptr(separators, i); 677| 371| IGRAPH_CHECK(igraph_vector_int_push_back(v, VECTOR(ap)[i])); ------------------ | | 752| 371| do { \ | | 753| 371| igraph_error_t igraph_i_ret = (expr); \ | | 754| 371| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 371| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 371] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 371| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 678| 371| } 679| 201| igraph_vector_int_destroy(&ap); 680| 201| IGRAPH_FINALLY_CLEAN(1); 681| 201| return IGRAPH_SUCCESS; 682| 720| } else if (conn == no_of_nodes - 1) { ------------------ | Branch (682:16): [True: 11, False: 709] ------------------ 683| 11| IGRAPH_CHECK(igraph_vector_int_list_resize(separators, no_of_nodes)); ------------------ | | 752| 11| do { \ | | 753| 11| igraph_error_t igraph_i_ret = (expr); \ | | 754| 11| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 11| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 11] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 11| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 684| 64| for (i = 0; i < no_of_nodes; i++) { ------------------ | Branch (684:21): [True: 53, False: 11] ------------------ 685| 53| igraph_vector_int_t *v = igraph_vector_int_list_get_ptr(separators, i); 686| 53| IGRAPH_CHECK(igraph_vector_int_resize(v, no_of_nodes - 1)); ------------------ | | 752| 53| do { \ | | 753| 53| igraph_error_t igraph_i_ret = (expr); \ | | 754| 53| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 53| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 53] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 53| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 687| 462| for (j = 0, k = 0; j < no_of_nodes; j++) { ------------------ | Branch (687:32): [True: 409, False: 53] ------------------ 688| 409| if (j != i) { ------------------ | Branch (688:21): [True: 356, False: 53] ------------------ 689| 356| VECTOR(*v)[k++] = j; ------------------ | | 69| 356|#define VECTOR(v) ((v).stor_begin) ------------------ 690| 356| } 691| 409| } 692| 53| } 693| 11| return IGRAPH_SUCCESS; 694| 11| } 695| | 696| | /* Work on a copy of 'graph' */ 697| 709| IGRAPH_CHECK(igraph_copy(&graph_copy, graph)); ------------------ | | 752| 709| do { \ | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 709] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 709| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 698| 709| IGRAPH_FINALLY(igraph_destroy, &graph_copy); ------------------ | | 695| 709| do { \ | | 696| 709| /* the following branch makes the compiler check the compatibility of \ | | 697| 709| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 709| * incorrect destructor function with the pointer */ \ | | 699| 709| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 709| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 709| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 699| 709| IGRAPH_CHECK(igraph_simplify(&graph_copy, /* multiple */ true, /* loops */ true, NULL)); ------------------ | | 752| 709| do { \ | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 709] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 709| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 700| | 701| | /* ---------------------------------------------------------------- */ 702| | /* 2 Find k vertices with the largest degrees (x1;..,xk). Check 703| | if these k vertices form a separating k-set of G */ 704| 709| IGRAPH_CHECK(igraph_vector_int_init(&X, conn)); ------------------ | | 752| 709| do { \ | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 709] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 709| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 705| 709| IGRAPH_FINALLY(igraph_vector_int_destroy, &X); ------------------ | | 695| 709| do { \ | | 696| 709| /* the following branch makes the compiler check the compatibility of \ | | 697| 709| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 709| * incorrect destructor function with the pointer */ \ | | 699| 709| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 709| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 709| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 706| 709| IGRAPH_CHECK(igraph_i_minimum_size_separators_topkdeg(&graph_copy, &X, k)); ------------------ | | 752| 709| do { \ | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 709] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 709| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 707| 709| IGRAPH_CHECK(igraph_is_separator(&graph_copy, igraph_vss_vector(&X), ------------------ | | 752| 709| do { \ | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 709] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 709| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 708| 709| &issepX)); 709| 709| if (issepX) { ------------------ | Branch (709:9): [True: 448, False: 261] ------------------ 710| 448| IGRAPH_CHECK(igraph_vector_int_list_push_back_copy(separators, &X)); ------------------ | | 752| 448| do { \ | | 753| 448| igraph_error_t igraph_i_ret = (expr); \ | | 754| 448| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 448| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 448] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 448| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 711| 448| } 712| | 713| | /* Create Gbar, the Even-Tarjan reduction of graph */ 714| 709| IGRAPH_VECTOR_INIT_FINALLY(&capacity, 0); ------------------ | | 109| 709| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \ | | ------------------ | | | | 752| 709| do { \ | | | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 709] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 709| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 110| 709| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0) | | ------------------ | | | | 695| 709| do { \ | | | | 696| 709| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 709| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 709| * incorrect destructor function with the pointer */ \ | | | | 699| 709| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 709| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 709| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (110:60): [Folded - Ignored] | | ------------------ ------------------ 715| 709| IGRAPH_CHECK(igraph_even_tarjan_reduction(&graph_copy, &Gbar, &capacity)); ------------------ | | 752| 709| do { \ | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 709] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 709| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 716| 709| IGRAPH_FINALLY(igraph_destroy, &Gbar); ------------------ | | 695| 709| do { \ | | 696| 709| /* the following branch makes the compiler check the compatibility of \ | | 697| 709| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 709| * incorrect destructor function with the pointer */ \ | | 699| 709| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 709| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 709| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 717| | 718| 709| IGRAPH_VECTOR_INIT_FINALLY(&phi, no_of_edges); ------------------ | | 109| 709| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \ | | ------------------ | | | | 752| 709| do { \ | | | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 709] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 709| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 110| 709| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0) | | ------------------ | | | | 695| 709| do { \ | | | | 696| 709| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 709| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 709| * incorrect destructor function with the pointer */ \ | | | | 699| 709| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 709| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 709| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (110:60): [Folded - Ignored] | | ------------------ ------------------ 719| | 720| | /* ---------------------------------------------------------------- */ 721| | /* 3 If v[j] != x[i] and v[j] is not adjacent to x[i] then */ 722| 2.42k| for (i = 0; i < k; i++) { ------------------ | Branch (722:17): [True: 1.71k, False: 709] ------------------ 723| | 724| 1.71k| IGRAPH_ALLOW_INTERRUPTION(); ------------------ | | 47| 1.71k| do { \ | | 48| 1.71k| if (igraph_i_interruption_handler) { \ | | ------------------ | | | Branch (48:13): [True: 0, False: 1.71k] | | ------------------ | | 49| 0| if (igraph_allow_interruption(NULL) != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (49:17): [True: 0, False: 0] | | ------------------ | | 50| 0| return IGRAPH_INTERRUPTED; \ | | 51| 0| } \ | | 52| 0| } \ | | 53| 1.71k| } while (0) | | ------------------ | | | Branch (53:14): [Folded - Ignored] | | ------------------ ------------------ 725| | 726| 20.4k| for (j = 0; j < no_of_nodes; j++) { ------------------ | Branch (726:21): [True: 18.7k, False: 1.71k] ------------------ 727| 18.7k| igraph_integer_t ii = VECTOR(X)[i]; ------------------ | | 69| 18.7k|#define VECTOR(v) ((v).stor_begin) ------------------ 728| 18.7k| igraph_real_t phivalue; 729| 18.7k| igraph_bool_t conn; 730| | 731| 18.7k| if (ii == j) { ------------------ | Branch (731:17): [True: 1.71k, False: 17.0k] ------------------ 732| 1.71k| continue; /* the same vertex */ 733| 1.71k| } 734| 17.0k| IGRAPH_CHECK(igraph_are_connected(&graph_copy, ii, j, &conn)); ------------------ | | 752| 17.0k| do { \ | | 753| 17.0k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 17.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 17.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 17.0k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 17.0k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 735| 17.0k| if (conn) { ------------------ | Branch (735:17): [True: 7.98k, False: 9.02k] ------------------ 736| 7.98k| continue; /* they are connected */ 737| 7.98k| } 738| | 739| | /* --------------------------------------------------------------- */ 740| | /* 4 Compute a maximum flow phi in Gbar from x[i] to v[j]. 741| | If |phi|=k, then */ 742| 9.02k| IGRAPH_CHECK(igraph_maxflow(&Gbar, &phivalue, &phi, /*cut=*/ 0, ------------------ | | 752| 9.02k| do { \ | | 753| 9.02k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 9.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 9.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 9.02k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 9.02k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 743| 9.02k| /*partition=*/ 0, /*partition2=*/ 0, 744| 9.02k| /* source= */ ii + no_of_nodes, 745| 9.02k| /* target= */ j, 746| 9.02k| &capacity, &stats)); 747| | 748| 9.02k| if (phivalue == k) { ------------------ | Branch (748:17): [True: 5.36k, False: 3.66k] ------------------ 749| | 750| | /* ------------------------------------------------------------- */ 751| | /* 5-6-7. Find all k-sets separating x[i] and v[j]. */ 752| 5.36k| igraph_vector_int_list_t stcuts; 753| 5.36k| IGRAPH_VECTOR_INT_LIST_INIT_FINALLY(&stcuts, 0); ------------------ | | 68| 5.36k| do { IGRAPH_CHECK(igraph_vector_int_list_init(v, size)); \ | | ------------------ | | | | 752| 5.36k| do { \ | | | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 69| 5.36k| IGRAPH_FINALLY(igraph_vector_int_list_destroy, v); } while (0) | | ------------------ | | | | 695| 5.36k| do { \ | | | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | | | 699| 5.36k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (69:69): [Folded - Ignored] | | ------------------ ------------------ 754| 5.36k| IGRAPH_CHECK(igraph_all_st_mincuts(&Gbar, /*value=*/ 0, ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 755| 5.36k| /*cuts=*/ &stcuts, 756| 5.36k| /*partition1s=*/ 0, 757| 5.36k| /*source=*/ ii + no_of_nodes, 758| 5.36k| /*target=*/ j, 759| 5.36k| /*capacity=*/ &capacity)); 760| | 761| 5.36k| IGRAPH_CHECK(igraph_i_minimum_size_separators_append(separators, &stcuts)); ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 762| 5.36k| igraph_vector_int_list_destroy(&stcuts); 763| 5.36k| IGRAPH_FINALLY_CLEAN(1); 764| | 765| 5.36k| } /* if phivalue == k */ 766| | 767| | /* --------------------------------------------------------------- */ 768| | /* 8 Add edge (x[i],v[j]) to G. */ 769| 9.02k| IGRAPH_CHECK(igraph_add_edge(&graph_copy, ii, j)); ------------------ | | 752| 9.02k| do { \ | | 753| 9.02k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 9.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 9.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 9.02k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 9.02k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 770| 9.02k| IGRAPH_CHECK(igraph_add_edge(&Gbar, ii + no_of_nodes, j)); ------------------ | | 752| 9.02k| do { \ | | 753| 9.02k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 9.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 9.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 9.02k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 9.02k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 771| 9.02k| IGRAPH_CHECK(igraph_add_edge(&Gbar, j + no_of_nodes, ii)); ------------------ | | 752| 9.02k| do { \ | | 753| 9.02k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 9.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 9.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 9.02k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 9.02k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 772| 9.02k| IGRAPH_CHECK(igraph_vector_push_back(&capacity, no_of_nodes)); ------------------ | | 752| 9.02k| do { \ | | 753| 9.02k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 9.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 9.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 9.02k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 9.02k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 773| 9.02k| IGRAPH_CHECK(igraph_vector_push_back(&capacity, no_of_nodes)); ------------------ | | 752| 9.02k| do { \ | | 753| 9.02k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 9.02k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 9.02k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 9.02k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 9.02k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 774| | 775| 9.02k| } /* for j= no_of_nodes - 1) { ------------------ | | 194| 709|#define IGRAPH_VIT_SIZE(vit) ((vit).end - (vit).start) ------------------ | Branch (48:9): [True: 0, False: 709] ------------------ 49| | /* Just need to check that we really have at least n-1 vertices in it */ 50| 0| igraph_vector_bool_t hit; 51| 0| igraph_integer_t nohit = 0; 52| 0| IGRAPH_CHECK(igraph_vector_bool_init(&hit, no_of_nodes)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 53| 0| IGRAPH_FINALLY(igraph_vector_bool_destroy, &hit); ------------------ | | 695| 0| do { \ | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 0| * incorrect destructor function with the pointer */ \ | | 699| 0| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 0| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 54| 0| for (IGRAPH_VIT_RESET(*vit); ------------------ | | 205| 0|#define IGRAPH_VIT_RESET(vit) ((vit).pos = (vit).start) ------------------ 55| 0| !IGRAPH_VIT_END(*vit); ------------------ | | 183| 0|#define IGRAPH_VIT_END(vit) ((vit).pos >= (vit).end) ------------------ | Branch (55:14): [True: 0, False: 0] ------------------ 56| 0| IGRAPH_VIT_NEXT(*vit)) { ------------------ | | 171| 0|#define IGRAPH_VIT_NEXT(vit) (++((vit).pos)) ------------------ 57| 0| igraph_integer_t v = IGRAPH_VIT_GET(*vit); ------------------ | | 218| 0| ((igraph_integer_t)(((vit).type == IGRAPH_VIT_RANGE) ? (vit).pos : \ | | ------------------ | | | Branch (218:25): [True: 0, False: 0] | | ------------------ | | 219| 0| VECTOR(*(vit).vec)[(vit).pos])) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 58| 0| if (!VECTOR(hit)[v]) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (58:17): [True: 0, False: 0] ------------------ 59| 0| nohit++; 60| 0| VECTOR(hit)[v] = 1; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 61| 0| } 62| 0| } 63| 0| igraph_vector_bool_destroy(&hit); 64| 0| IGRAPH_FINALLY_CLEAN(1); 65| 0| if (nohit >= no_of_nodes - 1) { ------------------ | Branch (65:13): [True: 0, False: 0] ------------------ 66| 0| *res = 0; 67| 0| return IGRAPH_SUCCESS; 68| 0| } 69| 0| } 70| | 71| | /* Remove the given vertices from the graph, do a breadth-first 72| | search and check the number of components */ 73| | 74| 709| if (except < 0) { ------------------ | Branch (74:9): [True: 709, False: 0] ------------------ 75| 709| for (IGRAPH_VIT_RESET(*vit); ------------------ | | 205| 709|#define IGRAPH_VIT_RESET(vit) ((vit).pos = (vit).start) ------------------ 76| 2.42k| !IGRAPH_VIT_END(*vit); ------------------ | | 183| 2.42k|#define IGRAPH_VIT_END(vit) ((vit).pos >= (vit).end) ------------------ | Branch (76:14): [True: 1.71k, False: 709] ------------------ 77| 1.71k| IGRAPH_VIT_NEXT(*vit)) { ------------------ | | 171| 1.71k|#define IGRAPH_VIT_NEXT(vit) (++((vit).pos)) ------------------ 78| 1.71k| VECTOR(*removed)[ IGRAPH_VIT_GET(*vit) ] = 1; ------------------ | | 69| 1.71k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*removed)[ IGRAPH_VIT_GET(*vit) ] = 1; ------------------ | | 218| 1.71k| ((igraph_integer_t)(((vit).type == IGRAPH_VIT_RANGE) ? (vit).pos : \ | | ------------------ | | | Branch (218:25): [True: 0, False: 1.71k] | | ------------------ | | 219| 1.71k| VECTOR(*(vit).vec)[(vit).pos])) | | ------------------ | | | | 69| 1.71k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 79| 1.71k| } 80| 709| } else { 81| | /* There is an exception */ 82| 0| igraph_integer_t i; 83| 0| for (i = 0, IGRAPH_VIT_RESET(*vit); ------------------ | | 205| 0|#define IGRAPH_VIT_RESET(vit) ((vit).pos = (vit).start) ------------------ 84| 0| i < except; ------------------ | Branch (84:14): [True: 0, False: 0] ------------------ 85| 0| i++, IGRAPH_VIT_NEXT(*vit)) { ------------------ | | 171| 0|#define IGRAPH_VIT_NEXT(vit) (++((vit).pos)) ------------------ 86| 0| VECTOR(*removed)[ IGRAPH_VIT_GET(*vit) ] = 1; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*removed)[ IGRAPH_VIT_GET(*vit) ] = 1; ------------------ | | 218| 0| ((igraph_integer_t)(((vit).type == IGRAPH_VIT_RANGE) ? (vit).pos : \ | | ------------------ | | | Branch (218:25): [True: 0, False: 0] | | ------------------ | | 219| 0| VECTOR(*(vit).vec)[(vit).pos])) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 87| 0| } 88| 0| for (IGRAPH_VIT_NEXT(*vit); ------------------ | | 171| 0|#define IGRAPH_VIT_NEXT(vit) (++((vit).pos)) ------------------ 89| 0| !IGRAPH_VIT_END(*vit); ------------------ | | 183| 0|#define IGRAPH_VIT_END(vit) ((vit).pos >= (vit).end) ------------------ | Branch (89:14): [True: 0, False: 0] ------------------ 90| 0| IGRAPH_VIT_NEXT(*vit)) { ------------------ | | 171| 0|#define IGRAPH_VIT_NEXT(vit) (++((vit).pos)) ------------------ 91| 0| VECTOR(*removed)[ IGRAPH_VIT_GET(*vit) ] = 1; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*removed)[ IGRAPH_VIT_GET(*vit) ] = 1; ------------------ | | 218| 0| ((igraph_integer_t)(((vit).type == IGRAPH_VIT_RANGE) ? (vit).pos : \ | | ------------------ | | | Branch (218:25): [True: 0, False: 0] | | ------------------ | | 219| 0| VECTOR(*(vit).vec)[(vit).pos])) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 92| 0| } 93| 0| } 94| | 95| | /* Look for the first node that is not removed */ 96| 1.62k| while (start < no_of_nodes && VECTOR(*removed)[start]) { ------------------ | | 69| 1.62k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (96:12): [True: 1.62k, False: 0] | Branch (96:35): [True: 913, False: 709] ------------------ 97| 913| start++; 98| 913| } 99| | 100| 709| if (start == no_of_nodes) { ------------------ | Branch (100:9): [True: 0, False: 709] ------------------ 101| 0| IGRAPH_ERROR("All vertices are included in the separator", ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 102| 0| IGRAPH_EINVAL); 103| 0| } 104| | 105| 709| IGRAPH_CHECK(igraph_dqueue_int_push(Q, start)); ------------------ | | 752| 709| do { \ | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 709] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 709| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 106| 709| VECTOR(*removed)[start] = 1; ------------------ | | 69| 709|#define VECTOR(v) ((v).stor_begin) ------------------ 107| 4.77k| while (!igraph_dqueue_int_empty(Q)) { ------------------ | Branch (107:12): [True: 4.06k, False: 709] ------------------ 108| 4.06k| igraph_integer_t node = igraph_dqueue_int_pop(Q); 109| 4.06k| igraph_integer_t j, n; 110| 4.06k| IGRAPH_CHECK(igraph_neighbors(graph, neis, node, IGRAPH_ALL)); ------------------ | | 752| 4.06k| do { \ | | 753| 4.06k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 4.06k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 4.06k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 4.06k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 4.06k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 111| 4.06k| n = igraph_vector_int_size(neis); 112| 15.8k| for (j = 0; j < n; j++) { ------------------ | Branch (112:21): [True: 11.7k, False: 4.06k] ------------------ 113| 11.7k| igraph_integer_t nei = VECTOR(*neis)[j]; ------------------ | | 69| 11.7k|#define VECTOR(v) ((v).stor_begin) ------------------ 114| 11.7k| if (!VECTOR(*removed)[nei]) { ------------------ | | 69| 11.7k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (114:17): [True: 3.35k, False: 8.41k] ------------------ 115| 3.35k| IGRAPH_CHECK(igraph_dqueue_int_push(Q, nei)); ------------------ | | 752| 3.35k| do { \ | | 753| 3.35k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 3.35k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 3.35k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 3.35k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 3.35k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 116| 3.35k| VECTOR(*removed)[nei] = 1; ------------------ | | 69| 3.35k|#define VECTOR(v) ((v).stor_begin) ------------------ 117| 3.35k| } 118| 11.7k| } 119| 4.06k| } 120| | 121| | /* Look for the next node that was neither removed, not visited */ 122| 4.30k| while (start < no_of_nodes && VECTOR(*removed)[start]) { ------------------ | | 69| 4.04k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (122:12): [True: 4.04k, False: 261] | Branch (122:35): [True: 3.59k, False: 448] ------------------ 123| 3.59k| start++; 124| 3.59k| } 125| | 126| | /* If there is another component, then we have a separator */ 127| 709| *res = (start < no_of_nodes); 128| | 129| 709| return IGRAPH_SUCCESS; 130| 709|} separators.c:igraph_i_connected_components_leaveout: 272| 115k| igraph_dqueue_int_t *Q) { 273| | 274| | /* Another trick: we use the same 'leaveout' vector to mark the 275| | * vertices that were already found in the BFS 276| | */ 277| | 278| 115k| igraph_integer_t i, no_of_nodes = igraph_adjlist_size(adjlist); 279| | 280| 115k| igraph_dqueue_int_clear(Q); 281| 115k| igraph_vector_int_clear(components); 282| | 283| 1.76M| for (i = 0; i < no_of_nodes; i++) { ------------------ | Branch (283:17): [True: 1.65M, False: 115k] ------------------ 284| | 285| 1.65M| if (VECTOR(*leaveout)[i] == *mark) { ------------------ | | 69| 1.65M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (285:13): [True: 1.35M, False: 295k] ------------------ 286| 1.35M| continue; 287| 1.35M| } 288| | 289| 295k| VECTOR(*leaveout)[i] = *mark; ------------------ | | 69| 295k|#define VECTOR(v) ((v).stor_begin) ------------------ 290| 295k| IGRAPH_CHECK(igraph_dqueue_int_push(Q, i)); ------------------ | | 752| 295k| do { \ | | 753| 295k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 295k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 295k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 295k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 295k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 291| 295k| IGRAPH_CHECK(igraph_vector_int_push_back(components, i)); ------------------ | | 752| 295k| do { \ | | 753| 295k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 295k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 295k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 295k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 295k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 292| | 293| 1.06M| while (!igraph_dqueue_int_empty(Q)) { ------------------ | Branch (293:16): [True: 768k, False: 295k] ------------------ 294| 768k| igraph_integer_t act_node = igraph_dqueue_int_pop(Q); 295| 768k| igraph_vector_int_t *neis = igraph_adjlist_get(adjlist, act_node); ------------------ | | 77| 768k|#define igraph_adjlist_get(al,no) (&(al)->adjs[(igraph_integer_t)(no)]) ------------------ 296| 768k| igraph_integer_t j, n = igraph_vector_int_size(neis); 297| 3.73M| for (j = 0; j < n; j++) { ------------------ | Branch (297:25): [True: 2.96M, False: 768k] ------------------ 298| 2.96M| igraph_integer_t nei = VECTOR(*neis)[j]; ------------------ | | 69| 2.96M|#define VECTOR(v) ((v).stor_begin) ------------------ 299| 2.96M| if (VECTOR(*leaveout)[nei] == *mark) { ------------------ | | 69| 2.96M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (299:21): [True: 2.49M, False: 473k] ------------------ 300| 2.49M| continue; 301| 2.49M| } 302| 473k| IGRAPH_CHECK(igraph_dqueue_int_push(Q, nei)); ------------------ | | 752| 473k| do { \ | | 753| 473k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 473k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 473k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 473k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 473k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 303| 473k| VECTOR(*leaveout)[nei] = *mark; ------------------ | | 69| 473k|#define VECTOR(v) ((v).stor_begin) ------------------ 304| 473k| IGRAPH_CHECK(igraph_vector_int_push_back(components, nei)); ------------------ | | 752| 473k| do { \ | | 753| 473k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 473k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 473k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 473k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 473k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 305| 473k| } 306| 768k| } 307| | 308| 295k| IGRAPH_CHECK(igraph_vector_int_push_back(components, -1)); ------------------ | | 752| 295k| do { \ | | 753| 295k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 295k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 295k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 295k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 295k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 309| 295k| } 310| | 311| 115k| UPDATEMARK(); ------------------ | | 260| 115k|#define UPDATEMARK() do { \ | | 261| 115k| (*mark)++; \ | | 262| 115k| if (!(*mark)) { \ | | ------------------ | | | Branch (262:13): [True: 0, False: 115k] | | ------------------ | | 263| 0| igraph_vector_int_null(leaveout); \ | | 264| 0| (*mark)=1; \ | | 265| 0| } \ | | 266| 115k| } while (0) | | ------------------ | | | Branch (266:14): [Folded - Ignored] | | ------------------ ------------------ 312| | 313| 115k| return IGRAPH_SUCCESS; 314| 115k|} separators.c:igraph_i_separators_store: 338| 115k| igraph_vector_int_t *sorter) { 339| | 340| | /* We need to store N(C), the neighborhood of C, but only if it is 341| | * not already stored among the separators. 342| | */ 343| | 344| 115k| igraph_integer_t cptr = 0, next, complen = igraph_vector_int_size(components); 345| | 346| 410k| while (cptr < complen) { ------------------ | Branch (346:12): [True: 295k, False: 115k] ------------------ 347| 295k| igraph_integer_t saved = cptr; 348| 295k| igraph_vector_int_clear(sorter); 349| | 350| | /* Calculate N(C) for the next C */ 351| | 352| 1.06M| while ( (next = VECTOR(*components)[cptr++]) != -1) { ------------------ | | 69| 1.06M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (352:17): [True: 768k, False: 295k] ------------------ 353| 768k| VECTOR(*leaveout)[next] = *mark; ------------------ | | 69| 768k|#define VECTOR(v) ((v).stor_begin) ------------------ 354| 768k| } 355| 295k| cptr = saved; 356| | 357| 1.06M| while ( (next = VECTOR(*components)[cptr++]) != -1) { ------------------ | | 69| 1.06M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (357:17): [True: 768k, False: 295k] ------------------ 358| 768k| igraph_vector_int_t *neis = igraph_adjlist_get(adjlist, next); ------------------ | | 77| 768k|#define igraph_adjlist_get(al,no) (&(al)->adjs[(igraph_integer_t)(no)]) ------------------ 359| 768k| igraph_integer_t j, nn = igraph_vector_int_size(neis); 360| 3.73M| for (j = 0; j < nn; j++) { ------------------ | Branch (360:25): [True: 2.96M, False: 768k] ------------------ 361| 2.96M| igraph_integer_t nei = VECTOR(*neis)[j]; ------------------ | | 69| 2.96M|#define VECTOR(v) ((v).stor_begin) ------------------ 362| 2.96M| if (VECTOR(*leaveout)[nei] != *mark) { ------------------ | | 69| 2.96M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (362:21): [True: 967k, False: 1.99M] ------------------ 363| 967k| IGRAPH_CHECK(igraph_vector_int_push_back(sorter, nei)); ------------------ | | 752| 967k| do { \ | | 753| 967k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 967k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 967k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 967k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 967k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 364| 967k| VECTOR(*leaveout)[nei] = *mark; ------------------ | | 69| 967k|#define VECTOR(v) ((v).stor_begin) ------------------ 365| 967k| } 366| 2.96M| } 367| 768k| } 368| 295k| igraph_vector_int_sort(sorter); 369| | 370| 295k| UPDATEMARK(); ------------------ | | 260| 295k|#define UPDATEMARK() do { \ | | 261| 295k| (*mark)++; \ | | 262| 295k| if (!(*mark)) { \ | | ------------------ | | | Branch (262:13): [True: 0, False: 295k] | | ------------------ | | 263| 0| igraph_vector_int_null(leaveout); \ | | 264| 0| (*mark)=1; \ | | 265| 0| } \ | | 266| 295k| } while (0) | | ------------------ | | | Branch (266:14): [Folded - Ignored] | | ------------------ ------------------ 371| | 372| | /* Add it to the list of separators, if it is new */ 373| 295k| if (igraph_i_separators_is_not_seen_yet(separators, sorter)) { ------------------ | Branch (373:13): [True: 27.9k, False: 267k] ------------------ 374| 27.9k| IGRAPH_CHECK(igraph_vector_int_list_push_back_copy(separators, sorter)); ------------------ | | 752| 27.9k| do { \ | | 753| 27.9k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 27.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 27.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 27.9k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 27.9k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 375| 27.9k| } 376| 295k| } /* while cptr < complen */ 377| | 378| 115k| return IGRAPH_SUCCESS; 379| 115k|} separators.c:igraph_i_separators_is_not_seen_yet: 318| 295k|) { 319| | 320| 295k| igraph_integer_t co, nocomps = igraph_vector_int_list_size(comps); 321| | 322| 6.48M| for (co = 0; co < nocomps; co++) { ------------------ | Branch (322:18): [True: 6.46M, False: 27.9k] ------------------ 323| 6.46M| igraph_vector_int_t *act = igraph_vector_int_list_get_ptr(comps, co); 324| 6.46M| if (igraph_vector_int_all_e(act, newc)) { ------------------ | Branch (324:13): [True: 267k, False: 6.19M] ------------------ 325| 267k| return false; 326| 267k| } 327| 6.46M| } 328| | 329| | /* If not found, then it is new */ 330| 27.9k| return true; 331| 295k|} separators.c:igraph_i_minimum_size_separators_topkdeg: 590| 709|) { 591| 709| igraph_integer_t no_of_nodes = igraph_vcount(graph); 592| 709| igraph_vector_int_t deg, order; 593| 709| igraph_integer_t i; 594| | 595| 709| IGRAPH_VECTOR_INT_INIT_FINALLY(°, no_of_nodes); ------------------ | | 124| 709| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 709| do { \ | | | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 709] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 709| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 709| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 709| do { \ | | | | 696| 709| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 709| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 709| * incorrect destructor function with the pointer */ \ | | | | 699| 709| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 709| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 709| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 596| 709| IGRAPH_VECTOR_INT_INIT_FINALLY(&order, no_of_nodes); ------------------ | | 124| 709| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 709| do { \ | | | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 709] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 709| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 709| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 709| do { \ | | | | 696| 709| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 709| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 709| * incorrect destructor function with the pointer */ \ | | | | 699| 709| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 709| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 709| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 597| 709| IGRAPH_CHECK(igraph_degree(graph, °, igraph_vss_all(), IGRAPH_ALL, ------------------ | | 752| 709| do { \ | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 709] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 709| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 598| 709| /*loops=*/ 0)); 599| | 600| 709| IGRAPH_CHECK(igraph_vector_int_order1(°, &order, no_of_nodes)); ------------------ | | 752| 709| do { \ | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 709] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 709| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 601| 709| IGRAPH_CHECK(igraph_vector_int_resize(res, k)); ------------------ | | 752| 709| do { \ | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 709] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 709| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 602| 2.42k| for (i = 0; i < k; i++) { ------------------ | Branch (602:17): [True: 1.71k, False: 709] ------------------ 603| 1.71k| VECTOR(*res)[i] = VECTOR(order)[no_of_nodes - 1 - i]; ------------------ | | 69| 1.71k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*res)[i] = VECTOR(order)[no_of_nodes - 1 - i]; ------------------ | | 69| 1.71k|#define VECTOR(v) ((v).stor_begin) ------------------ 604| 1.71k| } 605| | 606| 709| igraph_vector_int_destroy(&order); 607| 709| igraph_vector_int_destroy(°); 608| 709| IGRAPH_FINALLY_CLEAN(2); 609| | 610| 709| return IGRAPH_SUCCESS; 611| 709|} separators.c:igraph_i_minimum_size_separators_append: 556| 5.36k|) { 557| | 558| 5.36k| igraph_integer_t olen = igraph_vector_int_list_size(old); 559| 5.36k| igraph_integer_t j; 560| | 561| 19.2k| while (!igraph_vector_int_list_empty(new)) { ------------------ | Branch (561:12): [True: 13.8k, False: 5.36k] ------------------ 562| 13.8k| igraph_vector_int_t *oldvec; 563| 13.8k| igraph_vector_int_t *newvec = igraph_vector_int_list_tail_ptr(new); 564| | 565| | /* Check whether the separator is already in `old' */ 566| 321k| for (j = 0; j < olen; j++) { ------------------ | Branch (566:21): [True: 307k, False: 13.7k] ------------------ 567| 307k| igraph_vector_int_t *oldvec = igraph_vector_int_list_get_ptr(old, j); 568| 307k| if (igraph_vector_int_all_e(oldvec, newvec)) { ------------------ | Branch (568:17): [True: 142, False: 307k] ------------------ 569| 142| break; 570| 142| } 571| 307k| } 572| | 573| 13.8k| if (j == olen) { ------------------ | Branch (573:13): [True: 13.7k, False: 142] ------------------ 574| | /* We have found a new separator, append it to `old'. We do it by 575| | * extending it with an empty vector and then swapping it with 576| | * the new vector to be appended */ 577| 13.7k| IGRAPH_CHECK(igraph_vector_int_list_push_back_new(old, &oldvec)); ------------------ | | 752| 13.7k| do { \ | | 753| 13.7k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 13.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 13.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 13.7k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 13.7k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 578| 13.7k| igraph_vector_int_swap(oldvec, newvec); 579| 13.7k| olen++; 580| 13.7k| } 581| | 582| 13.8k| igraph_vector_int_list_discard_back(new); 583| 13.8k| } 584| | 585| 5.36k| return IGRAPH_SUCCESS; 586| 5.36k|} igraph_create: 67| 42.7k| igraph_integer_t n, igraph_bool_t directed) { 68| 42.7k| igraph_bool_t has_edges = igraph_vector_int_size(edges) > 0; 69| 42.7k| igraph_integer_t max; 70| | 71| 42.7k| if (igraph_vector_int_size(edges) % 2 != 0) { ------------------ | Branch (71:9): [True: 0, False: 42.7k] ------------------ 72| 0| IGRAPH_ERROR("Invalid (odd) edges vector.", IGRAPH_EINVEVECTOR); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 73| 0| } 74| 42.7k| if (has_edges && !igraph_vector_int_isininterval(edges, 0, IGRAPH_VCOUNT_MAX-1)) { ------------------ | | 106| 41.9k|#define IGRAPH_VCOUNT_MAX (IGRAPH_INTEGER_MAX-1) | | ------------------ | | | | 78| 41.9k|# define IGRAPH_INTEGER_MAX INT64_MAX | | ------------------ ------------------ | Branch (74:9): [True: 41.9k, False: 824] | Branch (74:22): [True: 0, False: 41.9k] ------------------ 75| 0| IGRAPH_ERROR("Invalid (negative or too large) vertex ID.", IGRAPH_EINVVID); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 76| 0| } 77| | 78| | /* The + 1 here cannot overflow as above we have already 79| | * checked that vertex IDs are within range. */ 80| 42.7k| max = has_edges ? igraph_vector_int_max(edges) + 1 : 0; ------------------ | Branch (80:11): [True: 41.9k, False: 824] ------------------ 81| | 82| 42.7k| IGRAPH_CHECK(igraph_empty(graph, n, directed)); ------------------ | | 752| 42.7k| do { \ | | 753| 42.7k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 42.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 42.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 42.7k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 42.7k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 83| 42.7k| IGRAPH_FINALLY(igraph_destroy, graph); ------------------ | | 695| 42.7k| do { \ | | 696| 42.7k| /* the following branch makes the compiler check the compatibility of \ | | 697| 42.7k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 42.7k| * incorrect destructor function with the pointer */ \ | | 699| 42.7k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 42.7k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 42.7k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 84| 42.7k| if (has_edges) { ------------------ | Branch (84:9): [True: 41.9k, False: 824] ------------------ 85| 41.9k| n = igraph_vcount(graph); 86| 41.9k| if (n < max) { ------------------ | Branch (86:13): [True: 1.15k, False: 40.7k] ------------------ 87| 1.15k| IGRAPH_CHECK(igraph_add_vertices(graph, (max - n), 0)); ------------------ | | 752| 1.15k| do { \ | | 753| 1.15k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.15k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.15k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.15k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.15k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 88| 1.15k| } 89| 41.9k| IGRAPH_CHECK(igraph_add_edges(graph, edges, 0)); ------------------ | | 752| 41.9k| do { \ | | 753| 41.9k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 41.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 41.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 41.9k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 41.9k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 90| 41.9k| } 91| | 92| 42.7k| IGRAPH_FINALLY_CLEAN(1); 93| 42.7k| return IGRAPH_SUCCESS; 94| 42.7k|} igraph_buckets_init: 48| 43.8k|igraph_error_t igraph_buckets_init(igraph_buckets_t *b, igraph_integer_t bsize, igraph_integer_t size) { 49| 43.8k| IGRAPH_VECTOR_INT_INIT_FINALLY(&b->bptr, bsize); ------------------ | | 124| 43.8k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 43.8k| do { \ | | | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 43.8k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 43.8k| do { \ | | | | 696| 43.8k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 43.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 43.8k| * incorrect destructor function with the pointer */ \ | | | | 699| 43.8k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 43.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 50| 43.8k| IGRAPH_VECTOR_INT_INIT_FINALLY(&b->buckets, size); ------------------ | | 124| 43.8k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 43.8k| do { \ | | | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 43.8k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 43.8k| do { \ | | | | 696| 43.8k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 43.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 43.8k| * incorrect destructor function with the pointer */ \ | | | | 699| 43.8k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 43.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 51| 43.8k| b->max = -1; b->no = 0; 52| 43.8k| IGRAPH_FINALLY_CLEAN(2); 53| 43.8k| return IGRAPH_SUCCESS; 54| 43.8k|} igraph_buckets_destroy: 56| 43.8k|void igraph_buckets_destroy(igraph_buckets_t *b) { 57| 43.8k| igraph_vector_int_destroy(&b->bptr); 58| 43.8k| igraph_vector_int_destroy(&b->buckets); 59| 43.8k|} igraph_buckets_popmax: 61| 1.34M|igraph_integer_t igraph_buckets_popmax(igraph_buckets_t *b) { 62| | /* Precondition: there is at least a non-empty bucket */ 63| | /* Search for the highest bucket first */ 64| 1.34M| igraph_integer_t max; 65| 1.93M| while ( (max = VECTOR(b->bptr)[b->max]) == 0) { ------------------ | | 69| 1.93M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (65:13): [True: 588k, False: 1.34M] ------------------ 66| 588k| b->max --; 67| 588k| } 68| 1.34M| VECTOR(b->bptr)[b->max] = VECTOR(b->buckets)[max - 1]; ------------------ | | 69| 1.34M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(b->bptr)[b->max] = VECTOR(b->buckets)[max - 1]; ------------------ | | 69| 1.34M|#define VECTOR(v) ((v).stor_begin) ------------------ 69| 1.34M| b->no--; 70| | 71| 1.34M| return max - 1; 72| 1.34M|} igraph_buckets_empty: 81| 1.40M|igraph_bool_t igraph_buckets_empty(const igraph_buckets_t *b) { 82| 1.40M| return (b->no == 0); 83| 1.40M|} igraph_buckets_empty_bucket: 86| 391k| igraph_integer_t bucket) { 87| 391k| return VECTOR(b->bptr)[bucket] == 0; ------------------ | | 69| 391k|#define VECTOR(v) ((v).stor_begin) ------------------ 88| 391k|} igraph_buckets_add: 91| 1.35M| igraph_integer_t elem) { 92| | 93| 1.35M| VECTOR(b->buckets)[elem] = VECTOR(b->bptr)[bucket]; ------------------ | | 69| 1.35M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(b->buckets)[elem] = VECTOR(b->bptr)[bucket]; ------------------ | | 69| 1.35M|#define VECTOR(v) ((v).stor_begin) ------------------ 94| 1.35M| VECTOR(b->bptr)[bucket] = elem + 1; ------------------ | | 69| 1.35M|#define VECTOR(v) ((v).stor_begin) ------------------ 95| 1.35M| if (bucket > b->max) { ------------------ | Branch (95:9): [True: 361k, False: 993k] ------------------ 96| 361k| b->max = bucket; 97| 361k| } 98| 1.35M| b->no++; 99| 1.35M|} igraph_buckets_clear: 101| 60.1k|void igraph_buckets_clear(igraph_buckets_t *b) { 102| 60.1k| igraph_vector_int_null(&b->bptr); 103| 60.1k| igraph_vector_int_null(&b->buckets); 104| 60.1k| b->max = -1; 105| 60.1k| b->no = 0; 106| 60.1k|} igraph_dbuckets_init: 108| 43.8k|igraph_error_t igraph_dbuckets_init(igraph_dbuckets_t *b, igraph_integer_t bsize, igraph_integer_t size) { 109| 43.8k| IGRAPH_VECTOR_INT_INIT_FINALLY(&b->bptr, bsize); ------------------ | | 124| 43.8k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 43.8k| do { \ | | | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 43.8k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 43.8k| do { \ | | | | 696| 43.8k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 43.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 43.8k| * incorrect destructor function with the pointer */ \ | | | | 699| 43.8k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 43.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 110| 43.8k| IGRAPH_VECTOR_INT_INIT_FINALLY(&b->next, size); ------------------ | | 124| 43.8k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 43.8k| do { \ | | | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 43.8k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 43.8k| do { \ | | | | 696| 43.8k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 43.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 43.8k| * incorrect destructor function with the pointer */ \ | | | | 699| 43.8k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 43.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 111| 43.8k| IGRAPH_VECTOR_INT_INIT_FINALLY(&b->prev, size); ------------------ | | 124| 43.8k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 43.8k| do { \ | | | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 43.8k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 43.8k| do { \ | | | | 696| 43.8k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 43.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 43.8k| * incorrect destructor function with the pointer */ \ | | | | 699| 43.8k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 43.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 112| 43.8k| b->max = -1; b->no = 0; 113| 43.8k| IGRAPH_FINALLY_CLEAN(3); 114| 43.8k| return IGRAPH_SUCCESS; 115| 43.8k|} igraph_dbuckets_destroy: 117| 43.8k|void igraph_dbuckets_destroy(igraph_dbuckets_t *b) { 118| 43.8k| igraph_vector_int_destroy(&b->bptr); 119| 43.8k| igraph_vector_int_destroy(&b->next); 120| 43.8k| igraph_vector_int_destroy(&b->prev); 121| 43.8k|} igraph_dbuckets_clear: 123| 45.7k|void igraph_dbuckets_clear(igraph_dbuckets_t *b) { 124| 45.7k| igraph_vector_int_null(&b->bptr); 125| 45.7k| igraph_vector_int_null(&b->next); 126| 45.7k| igraph_vector_int_null(&b->prev); 127| 45.7k| b->max = -1; 128| 45.7k| b->no = 0; 129| 45.7k|} igraph_dbuckets_pop: 139| 153k|igraph_integer_t igraph_dbuckets_pop(igraph_dbuckets_t *b, igraph_integer_t bucket) { 140| 153k| igraph_integer_t ret = VECTOR(b->bptr)[bucket] - 1; ------------------ | | 69| 153k|#define VECTOR(v) ((v).stor_begin) ------------------ 141| 153k| igraph_integer_t next = VECTOR(b->next)[ret]; ------------------ | | 69| 153k|#define VECTOR(v) ((v).stor_begin) ------------------ 142| 153k| VECTOR(b->bptr)[bucket] = next; ------------------ | | 69| 153k|#define VECTOR(v) ((v).stor_begin) ------------------ 143| 153k| if (next != 0) { ------------------ | Branch (143:9): [True: 83.2k, False: 70.2k] ------------------ 144| 83.2k| VECTOR(b->prev)[next - 1] = 0; ------------------ | | 69| 83.2k|#define VECTOR(v) ((v).stor_begin) ------------------ 145| 83.2k| } 146| | 147| 153k| b->no--; 148| 153k| return ret; 149| 153k|} igraph_dbuckets_empty_bucket: 156| 2.13M| igraph_integer_t bucket) { 157| 2.13M| return VECTOR(b->bptr)[bucket] == 0; ------------------ | | 69| 2.13M|#define VECTOR(v) ((v).stor_begin) ------------------ 158| 2.13M|} igraph_dbuckets_add: 161| 1.75M| igraph_integer_t elem) { 162| 1.75M| igraph_integer_t oldfirst = VECTOR(b->bptr)[bucket]; ------------------ | | 69| 1.75M|#define VECTOR(v) ((v).stor_begin) ------------------ 163| 1.75M| VECTOR(b->bptr)[bucket] = elem + 1; ------------------ | | 69| 1.75M|#define VECTOR(v) ((v).stor_begin) ------------------ 164| 1.75M| VECTOR(b->next)[elem] = oldfirst; ------------------ | | 69| 1.75M|#define VECTOR(v) ((v).stor_begin) ------------------ 165| 1.75M| if (oldfirst != 0) { ------------------ | Branch (165:9): [True: 1.09M, False: 661k] ------------------ 166| 1.09M| VECTOR(b->prev)[oldfirst - 1] = elem + 1; ------------------ | | 69| 1.09M|#define VECTOR(v) ((v).stor_begin) ------------------ 167| 1.09M| } 168| 1.75M| if (bucket > b->max) { ------------------ | Branch (168:9): [True: 400k, False: 1.35M] ------------------ 169| 400k| b->max = bucket; 170| 400k| } 171| 1.75M| b->no++; 172| 1.75M|} igraph_dbuckets_delete: 177| 917k| igraph_integer_t elem) { 178| 917k| if (VECTOR(b->bptr)[bucket] == elem + 1) { ------------------ | | 69| 917k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (178:9): [True: 575k, False: 341k] ------------------ 179| | /* First element in bucket */ 180| 575k| igraph_integer_t next = VECTOR(b->next)[elem]; ------------------ | | 69| 575k|#define VECTOR(v) ((v).stor_begin) ------------------ 181| 575k| if (next != 0) { ------------------ | Branch (181:13): [True: 304k, False: 271k] ------------------ 182| 304k| VECTOR(b->prev)[next - 1] = 0; ------------------ | | 69| 304k|#define VECTOR(v) ((v).stor_begin) ------------------ 183| 304k| } 184| 575k| VECTOR(b->bptr)[bucket] = next; ------------------ | | 69| 575k|#define VECTOR(v) ((v).stor_begin) ------------------ 185| 575k| } else { 186| 341k| igraph_integer_t next = VECTOR(b->next)[elem]; ------------------ | | 69| 341k|#define VECTOR(v) ((v).stor_begin) ------------------ 187| 341k| igraph_integer_t prev = VECTOR(b->prev)[elem]; ------------------ | | 69| 341k|#define VECTOR(v) ((v).stor_begin) ------------------ 188| 341k| if (next != 0) { ------------------ | Branch (188:13): [True: 205k, False: 136k] ------------------ 189| 205k| VECTOR(b->prev)[next - 1] = prev; ------------------ | | 69| 205k|#define VECTOR(v) ((v).stor_begin) ------------------ 190| 205k| } 191| 341k| if (prev != 0) { ------------------ | Branch (191:13): [True: 341k, False: 0] ------------------ 192| 341k| VECTOR(b->next)[prev - 1] = next; ------------------ | | 69| 341k|#define VECTOR(v) ((v).stor_begin) ------------------ 193| 341k| } 194| 341k| } 195| 917k| b->no--; 196| 917k|} igraph_dqueue_int_init: 76| 100k|igraph_error_t FUNCTION(igraph_dqueue, init)(TYPE(igraph_dqueue)* q, igraph_integer_t capacity) { 77| 100k| IGRAPH_ASSERT(q != NULL); ------------------ | | 1107| 100k| do { \ | | 1108| 100k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 100k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 100k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 100k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 78| 100k| IGRAPH_ASSERT(capacity >= 0); ------------------ | | 1107| 100k| do { \ | | 1108| 100k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 100k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 100k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 100k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 79| | 80| 100k| if (capacity == 0) capacity = 1; ------------------ | Branch (80:9): [True: 19.7k, False: 80.3k] ------------------ 81| | 82| 100k| q->stor_begin = IGRAPH_CALLOC(capacity, BASE); ------------------ | | 32| 100k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [True: 100k, False: 0] | | ------------------ ------------------ 83| 100k| IGRAPH_CHECK_OOM(q->stor_begin, "Cannot initialize dqueue."); ------------------ | | 807| 100k| do { \ | | 808| 100k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 100k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 100k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 100k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 84| 100k| q->stor_end = q->stor_begin + capacity; 85| 100k| q->begin = q->stor_begin; 86| 100k| q->end = NULL; 87| | 88| 100k| return IGRAPH_SUCCESS; 89| 100k|} igraph_dqueue_int_destroy: 101| 100k|void FUNCTION(igraph_dqueue, destroy)(TYPE(igraph_dqueue)* q) { 102| 100k| IGRAPH_ASSERT(q != NULL); ------------------ | | 1107| 100k| do { \ | | 1108| 100k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 100k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 100k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 100k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 103| 100k| IGRAPH_FREE(q->stor_begin); /* sets to NULL */ ------------------ | | 35| 100k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 104| 100k|} igraph_dqueue_int_empty: 118| 3.57M|igraph_bool_t FUNCTION(igraph_dqueue, empty)(const TYPE(igraph_dqueue)* q) { 119| 3.57M| IGRAPH_ASSERT(q != NULL); ------------------ | | 1107| 3.57M| do { \ | | 1108| 3.57M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 3.57M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 3.57M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 3.57M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 120| 3.57M| IGRAPH_ASSERT(q->stor_begin != NULL); ------------------ | | 1107| 3.57M| do { \ | | 1108| 3.57M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 3.57M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 3.57M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 3.57M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 121| 3.57M| return q->end == NULL; 122| 3.57M|} igraph_dqueue_int_clear: 134| 116k|void FUNCTION(igraph_dqueue, clear)(TYPE(igraph_dqueue)* q) { 135| 116k| IGRAPH_ASSERT(q != NULL); ------------------ | | 1107| 116k| do { \ | | 1108| 116k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 116k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 116k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 116k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 136| 116k| IGRAPH_ASSERT(q->stor_begin != NULL); ------------------ | | 1107| 116k| do { \ | | 1108| 116k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 116k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 116k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 116k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 137| 116k| q->begin = q->stor_begin; 138| 116k| q->end = NULL; 139| 116k|} igraph_dqueue_int_size: 172| 111k|igraph_integer_t FUNCTION(igraph_dqueue, size)(const TYPE(igraph_dqueue)* q) { 173| 111k| IGRAPH_ASSERT(q != NULL); ------------------ | | 1107| 111k| do { \ | | 1108| 111k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 111k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 111k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 111k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 174| 111k| IGRAPH_ASSERT(q->stor_begin != NULL); ------------------ | | 1107| 111k| do { \ | | 1108| 111k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 111k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 111k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 111k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 175| 111k| if (q->end == NULL) { ------------------ | Branch (175:9): [True: 0, False: 111k] ------------------ 176| 0| return 0; 177| 111k| } else if (q->begin < q->end) { ------------------ | Branch (177:16): [True: 91.1k, False: 20.5k] ------------------ 178| 91.1k| return q->end - q->begin; 179| 91.1k| } else { 180| 20.5k| return q->stor_end - q->begin + q->end - q->stor_begin; 181| 20.5k| } 182| 111k|} igraph_dqueue_int_head: 197| 1.39k|BASE FUNCTION(igraph_dqueue, head)(const TYPE(igraph_dqueue)* q) { 198| 1.39k| IGRAPH_ASSERT(q != NULL); ------------------ | | 1107| 1.39k| do { \ | | 1108| 1.39k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 1.39k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.39k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 1.39k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 199| 1.39k| IGRAPH_ASSERT(q->stor_begin != NULL); ------------------ | | 1107| 1.39k| do { \ | | 1108| 1.39k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 1.39k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.39k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 1.39k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 200| 1.39k| IGRAPH_ASSERT(q->stor_end != NULL); /* queue is not empty */ ------------------ | | 1107| 1.39k| do { \ | | 1108| 1.39k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 1.39k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.39k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 1.39k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 201| 1.39k| return *(q->begin); 202| 1.39k|} igraph_dqueue_int_back: 217| 621k|BASE FUNCTION(igraph_dqueue, back)(const TYPE(igraph_dqueue)* q) { 218| 621k| IGRAPH_ASSERT(q != NULL); ------------------ | | 1107| 621k| do { \ | | 1108| 621k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 621k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 621k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 621k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 219| 621k| IGRAPH_ASSERT(q->stor_begin != NULL); ------------------ | | 1107| 621k| do { \ | | 1108| 621k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 621k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 621k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 621k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 220| 621k| IGRAPH_ASSERT(q->stor_end != NULL); /* queue is not empty */ ------------------ | | 1107| 621k| do { \ | | 1108| 621k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 621k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 621k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 621k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 221| 621k| if (q->end == q->stor_begin) { ------------------ | Branch (221:9): [True: 0, False: 621k] ------------------ 222| 0| return *(q->stor_end - 1); 223| 0| } 224| 621k| return *(q->end - 1); 225| 621k|} igraph_dqueue_int_pop: 241| 2.76M|BASE FUNCTION(igraph_dqueue, pop)(TYPE(igraph_dqueue)* q) { 242| 2.76M| IGRAPH_ASSERT(q != NULL); ------------------ | | 1107| 2.76M| do { \ | | 1108| 2.76M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 2.76M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.76M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 2.76M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 243| 2.76M| IGRAPH_ASSERT(q->stor_begin != NULL); ------------------ | | 1107| 2.76M| do { \ | | 1108| 2.76M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 2.76M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.76M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 2.76M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 244| 2.76M| IGRAPH_ASSERT(q->stor_end != NULL); /* queue is not empty */ ------------------ | | 1107| 2.76M| do { \ | | 1108| 2.76M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 2.76M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.76M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 2.76M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 245| 2.76M| BASE tmp = *(q->begin); ------------------ | | 71| 2.76M| #define BASE igraph_integer_t ------------------ 246| 2.76M| (q->begin)++; 247| 2.76M| if (q->begin == q->stor_end) { ------------------ | Branch (247:9): [True: 30.4k, False: 2.73M] ------------------ 248| 30.4k| q->begin = q->stor_begin; 249| 30.4k| } 250| 2.76M| if (q->begin == q->end) { ------------------ | Branch (250:9): [True: 898k, False: 1.86M] ------------------ 251| 898k| q->end = NULL; 252| 898k| } 253| | 254| 2.76M| return tmp; 255| 2.76M|} igraph_dqueue_int_pop_back: 271| 284k|BASE FUNCTION(igraph_dqueue, pop_back)(TYPE(igraph_dqueue)* q) { 272| 284k| BASE tmp; ------------------ | | 71| 284k| #define BASE igraph_integer_t ------------------ 273| 284k| IGRAPH_ASSERT(q != NULL); ------------------ | | 1107| 284k| do { \ | | 1108| 284k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 284k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 284k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 284k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 274| 284k| IGRAPH_ASSERT(q->stor_begin != NULL); ------------------ | | 1107| 284k| do { \ | | 1108| 284k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 284k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 284k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 284k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 275| 284k| IGRAPH_ASSERT(q->stor_end != NULL); /* queue is not empty */ ------------------ | | 1107| 284k| do { \ | | 1108| 284k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 284k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 284k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 284k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 276| 284k| if (q->end != q->stor_begin) { ------------------ | Branch (276:9): [True: 280k, False: 4.31k] ------------------ 277| 280k| tmp = *((q->end) - 1); 278| 280k| q->end = (q->end) - 1; 279| 280k| } else { 280| 4.31k| tmp = *((q->stor_end) - 1); 281| 4.31k| q->end = (q->stor_end) - 1; 282| 4.31k| } 283| 284k| if (q->begin == q->end) { ------------------ | Branch (283:9): [True: 62.9k, False: 221k] ------------------ 284| 62.9k| q->end = NULL; 285| 62.9k| } 286| | 287| 284k| return tmp; 288| 284k|} igraph_dqueue_int_push: 308| 3.05M|igraph_error_t FUNCTION(igraph_dqueue, push)(TYPE(igraph_dqueue)* q, BASE elem) { 309| 3.05M| IGRAPH_ASSERT(q != NULL); ------------------ | | 1107| 3.05M| do { \ | | 1108| 3.05M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 3.05M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 3.05M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 3.05M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 310| 3.05M| IGRAPH_ASSERT(q->stor_begin != NULL); ------------------ | | 1107| 3.05M| do { \ | | 1108| 3.05M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 3.05M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 3.05M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 3.05M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 311| 3.05M| if (q->begin != q->end) { ------------------ | Branch (311:9): [True: 3.01M, False: 43.8k] ------------------ 312| | /* not full */ 313| 3.01M| if (q->end == NULL) { ------------------ | Branch (313:13): [True: 962k, False: 2.04M] ------------------ 314| 962k| q->end = q->begin; 315| 962k| } 316| 3.01M| *(q->end) = elem; 317| 3.01M| (q->end)++; 318| 3.01M| if (q->end == q->stor_end) { ------------------ | Branch (318:13): [True: 60.7k, False: 2.95M] ------------------ 319| 60.7k| q->end = q->stor_begin; 320| 60.7k| } 321| 3.01M| } else { 322| | /* full, allocate more storage */ 323| | 324| 43.8k| BASE *bigger = NULL, *old = q->stor_begin; ------------------ | | 71| 43.8k| #define BASE igraph_integer_t ------------------ 325| 43.8k| igraph_integer_t old_size = q->stor_end - q->stor_begin; 326| 43.8k| igraph_integer_t new_capacity = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 78| 43.8k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_integer_t new_capacity = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 78| 43.8k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (326:41): [True: 43.8k, False: 0] ------------------ 327| | 328| 43.8k| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 78| 43.8k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (328:13): [True: 0, False: 43.8k] ------------------ 329| 0| IGRAPH_ERROR("Cannot push to dqueue, already at maximum size.", IGRAPH_EOVERFLOW); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 330| 0| } 331| 43.8k| if (new_capacity == 0) { ------------------ | Branch (331:13): [True: 0, False: 43.8k] ------------------ 332| 0| new_capacity = 1; 333| 0| } 334| | 335| 43.8k| bigger = IGRAPH_CALLOC(new_capacity, BASE); ------------------ | | 32| 43.8k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [True: 43.8k, False: 0] | | ------------------ ------------------ 336| 43.8k| IGRAPH_CHECK_OOM(bigger, "Cannot push to dqueue."); ------------------ | | 807| 43.8k| do { \ | | 808| 43.8k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 43.8k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 337| | 338| 43.8k| if (q->stor_end - q->begin) { ------------------ | Branch (338:13): [True: 43.8k, False: 0] ------------------ 339| 43.8k| memcpy(bigger, q->begin, 340| 43.8k| (size_t)(q->stor_end - q->begin) * sizeof(BASE)); 341| 43.8k| } 342| 43.8k| if (q->end - q->stor_begin > 0) { ------------------ | Branch (342:13): [True: 1.06k, False: 42.7k] ------------------ 343| 1.06k| memcpy(bigger + (q->stor_end - q->begin), q->stor_begin, 344| 1.06k| (size_t)(q->end - q->stor_begin) * sizeof(BASE)); 345| 1.06k| } 346| | 347| 43.8k| q->end = bigger + old_size; 348| 43.8k| q->stor_end = bigger + new_capacity; 349| 43.8k| q->stor_begin = bigger; 350| 43.8k| q->begin = bigger; 351| | 352| 43.8k| *(q->end) = elem; 353| 43.8k| (q->end)++; 354| 43.8k| if (q->end == q->stor_end) { ------------------ | Branch (354:13): [True: 17.9k, False: 25.8k] ------------------ 355| 17.9k| q->end = q->stor_begin; 356| 17.9k| } 357| | 358| 43.8k| IGRAPH_FREE(old); ------------------ | | 35| 43.8k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 359| 43.8k| } 360| | 361| 3.05M| return IGRAPH_SUCCESS; 362| 3.05M|} igraph_dqueue_int_get: 417| 83.9k|BASE FUNCTION(igraph_dqueue, get)(const TYPE(igraph_dqueue) *q, igraph_integer_t idx) { 418| 83.9k| IGRAPH_ASSERT(idx >= 0); ------------------ | | 1107| 83.9k| do { \ | | 1108| 83.9k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 83.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 83.9k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 83.9k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 419| 83.9k| IGRAPH_ASSERT(idx < FUNCTION(igraph_dqueue, size)(q)); ------------------ | | 1107| 83.9k| do { \ | | 1108| 83.9k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 83.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 83.9k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 83.9k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 420| 83.9k| if ((q->begin + idx < q->end) || ------------------ | Branch (420:9): [True: 72.0k, False: 11.9k] ------------------ 421| 83.9k| (q->begin >= q->end && q->begin + idx < q->stor_end)) { ------------------ | Branch (421:10): [True: 11.9k, False: 0] | Branch (421:32): [True: 11.9k, False: 0] ------------------ 422| 83.9k| return q->begin[idx]; 423| 83.9k| } else if (q->begin >= q->end && q->stor_begin + idx < q->end) { ------------------ | Branch (423:16): [True: 0, False: 0] | Branch (423:38): [True: 0, False: 0] ------------------ 424| 0| idx = idx - (q->stor_end - q->begin); 425| 0| return q->stor_begin[idx]; 426| 0| } else { 427| | /* The assertions at the top make it impossible to reach here, 428| | but omitting this branch would cause compiler warnings. */ 429| 0| IGRAPH_FATAL("Out of bounds access in dqueue."); ------------------ | | 1078| 0| do { \ | | 1079| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1080| 0| } while (0) | | ------------------ | | | Branch (1080:14): [Folded - Ignored] | | ------------------ ------------------ 430| 0| } 431| 83.9k|} igraph_set_error_handler: 225| 1.17k|igraph_error_handler_t *igraph_set_error_handler(igraph_error_handler_t *new_handler) { 226| 1.17k| igraph_error_handler_t *previous_handler = igraph_i_error_handler; 227| 1.17k| igraph_i_error_handler = new_handler; 228| 1.17k| return previous_handler; 229| 1.17k|} IGRAPH_FINALLY_REAL: 247| 3.24M|void IGRAPH_FINALLY_REAL(void (*func)(void*), void* ptr) { 248| 3.24M| int no = igraph_i_finally_stack_size; 249| 3.24M| if (no < 0) { ------------------ | Branch (249:9): [True: 0, False: 3.24M] ------------------ 250| | /* Reset finally stack in case fatal error handler does a longjmp instead of terminating the process: */ 251| 0| igraph_i_reset_finally_stack(); 252| 0| IGRAPH_FATALF("Corrupt finally stack: it contains %d elements.", no); ------------------ | | 1058| 0| do { \ | | 1059| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 1060| 0| __VA_ARGS__); \ | | 1061| 0| } while (0) | | ------------------ | | | Branch (1061:14): [Folded - Ignored] | | ------------------ ------------------ 253| 0| } 254| 3.24M| if (no >= (int) (sizeof(igraph_i_finally_stack) / sizeof(igraph_i_finally_stack[0]))) { ------------------ | Branch (254:9): [True: 0, False: 3.24M] ------------------ 255| | /* Reset finally stack in case fatal error handler does a longjmp instead of terminating the process: */ 256| 0| igraph_i_reset_finally_stack(); 257| 0| IGRAPH_FATALF("Finally stack too large: it contains %d elements.", no); ------------------ | | 1058| 0| do { \ | | 1059| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 1060| 0| __VA_ARGS__); \ | | 1061| 0| } while (0) | | ------------------ | | | Branch (1061:14): [Folded - Ignored] | | ------------------ ------------------ 258| 0| } 259| 3.24M| igraph_i_finally_stack[no].ptr = ptr; 260| 3.24M| igraph_i_finally_stack[no].func = func; 261| 3.24M| igraph_i_finally_stack[no].level = igraph_i_finally_stack_level; 262| 3.24M| igraph_i_finally_stack_size++; 263| 3.24M|} IGRAPH_FINALLY_CLEAN: 265| 1.24M|void IGRAPH_FINALLY_CLEAN(int minus) { 266| 1.24M| igraph_i_finally_stack_size -= minus; 267| 1.24M| if (igraph_i_finally_stack_size < 0) { ------------------ | Branch (267:9): [True: 0, False: 1.24M] ------------------ 268| 0| int left = igraph_i_finally_stack_size + minus; 269| | /* Reset finally stack in case fatal error handler does a longjmp instead of terminating the process: */ 270| 0| igraph_i_reset_finally_stack(); 271| 0| IGRAPH_FATALF("Corrupt finally stack: trying to pop %d element(s) when only %d left.", minus, left); ------------------ | | 1058| 0| do { \ | | 1059| 0| igraph_fatalf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 1060| 0| __VA_ARGS__); \ | | 1061| 0| } while (0) | | ------------------ | | | Branch (1061:14): [Folded - Ignored] | | ------------------ ------------------ 272| 0| } 273| 1.24M|} IGRAPH_FINALLY_STACK_SIZE: 286| 1.15k|int IGRAPH_FINALLY_STACK_SIZE(void) { 287| 1.15k| return igraph_i_finally_stack_size; 288| 1.15k|} IGRAPH_FINALLY_ENTER: 304| 68.9k|void IGRAPH_FINALLY_ENTER(void) { 305| 68.9k| int no = igraph_i_finally_stack_size; 306| | /* Level indices must always be in increasing order in the finally stack */ 307| 68.9k| if (no > 0 && igraph_i_finally_stack[no-1].level > igraph_i_finally_stack_level) { ------------------ | Branch (307:9): [True: 68.9k, False: 0] | Branch (307:19): [True: 0, False: 68.9k] ------------------ 308| | /* Reset finally stack in case fatal error handler does a longjmp instead of terminating the process: */ 309| 0| igraph_i_reset_finally_stack(); 310| 0| IGRAPH_FATAL("Corrupt finally stack: cannot create new finally stack level before last one is freed."); ------------------ | | 1078| 0| do { \ | | 1079| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1080| 0| } while (0) | | ------------------ | | | Branch (1080:14): [Folded - Ignored] | | ------------------ ------------------ 311| 0| } 312| 68.9k| igraph_i_finally_stack_level++; 313| 68.9k|} IGRAPH_FINALLY_EXIT: 326| 68.9k|void IGRAPH_FINALLY_EXIT(void) { 327| 68.9k| igraph_i_finally_stack_level--; 328| 68.9k| if (igraph_i_finally_stack_level < 0) { ------------------ | Branch (328:9): [True: 0, False: 68.9k] ------------------ 329| | /* Reset finally stack in case fatal error handler does a longjmp instead of terminating the process: */ 330| 0| igraph_i_reset_finally_stack(); 331| 0| IGRAPH_FATAL("Corrupt finally stack: trying to exit outermost finally stack level."); ------------------ | | 1078| 0| do { \ | | 1079| 0| igraph_fatal(reason, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1080| 0| } while (0) | | ------------------ | | | Branch (1080:14): [Folded - Ignored] | | ------------------ ------------------ 332| 0| } 333| 68.9k|} igraph_set_warning_handler: 401| 1.17k|igraph_warning_handler_t *igraph_set_warning_handler(igraph_warning_handler_t *new_handler) { 402| 1.17k| igraph_warning_handler_t *previous_handler = igraph_i_warning_handler; 403| 1.17k| igraph_i_warning_handler = new_handler; 404| 1.17k| return previous_handler; 405| 1.17k|} igraph_estack_init: 27| 5.36k| igraph_integer_t stacksize) { 28| 5.36k| IGRAPH_CHECK(igraph_vector_bool_init(&s->isin, setsize)); ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 29| 5.36k| IGRAPH_FINALLY(igraph_vector_bool_destroy, &s->isin); ------------------ | | 695| 5.36k| do { \ | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | 699| 5.36k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 5.36k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 30| 5.36k| IGRAPH_CHECK(igraph_stack_int_init(&s->stack, stacksize)); ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 31| 5.36k| IGRAPH_FINALLY_CLEAN(1); 32| 5.36k| return IGRAPH_SUCCESS; 33| 5.36k|} igraph_estack_destroy: 35| 5.36k|void igraph_estack_destroy(igraph_estack_t *s) { 36| 5.36k| igraph_stack_int_destroy(&s->stack); 37| 5.36k| igraph_vector_bool_destroy(&s->isin); 38| 5.36k|} igraph_estack_push: 40| 13.8k|igraph_error_t igraph_estack_push(igraph_estack_t *s, igraph_integer_t elem) { 41| 13.8k| if ( !VECTOR(s->isin)[elem] ) { ------------------ | | 69| 13.8k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (41:10): [True: 13.8k, False: 0] ------------------ 42| 13.8k| IGRAPH_CHECK(igraph_stack_int_push(&s->stack, elem)); ------------------ | | 752| 13.8k| do { \ | | 753| 13.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 13.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 13.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 43| 13.8k| VECTOR(s->isin)[elem] = 1; ------------------ | | 69| 13.8k|#define VECTOR(v) ((v).stor_begin) ------------------ 44| 13.8k| } 45| 13.8k| return IGRAPH_SUCCESS; 46| 13.8k|} igraph_estack_pop: 48| 13.8k|igraph_integer_t igraph_estack_pop(igraph_estack_t *s) { 49| 13.8k| igraph_integer_t elem = igraph_stack_int_pop(&s->stack); 50| 13.8k| VECTOR(s->isin)[elem] = 0; ------------------ | | 69| 13.8k|#define VECTOR(v) ((v).stor_begin) ------------------ 51| 13.8k| return elem; 52| 13.8k|} igraph_estack_iselement: 55| 48.5k| igraph_integer_t elem) { 56| 48.5k| return VECTOR(s->isin)[elem]; ------------------ | | 69| 48.5k|#define VECTOR(v) ((v).stor_begin) ------------------ 57| 48.5k|} igraph_marked_queue_int_init: 29| 5.36k| igraph_integer_t size) { 30| 5.36k| IGRAPH_CHECK(igraph_dqueue_int_init(&q->Q, 0)); ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 31| 5.36k| IGRAPH_FINALLY(igraph_dqueue_int_destroy, &q->Q); ------------------ | | 695| 5.36k| do { \ | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | 699| 5.36k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 5.36k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 32| 5.36k| IGRAPH_CHECK(igraph_vector_int_init(&q->set, size)); ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 33| 5.36k| q->mark = 1; 34| 5.36k| q->size = 0; 35| 5.36k| IGRAPH_FINALLY_CLEAN(1); 36| 5.36k| return IGRAPH_SUCCESS; 37| 5.36k|} igraph_marked_queue_int_destroy: 39| 5.36k|void igraph_marked_queue_int_destroy(igraph_marked_queue_int_t *q) { 40| 5.36k| igraph_vector_int_destroy(&q->set); 41| 5.36k| igraph_dqueue_int_destroy(&q->Q); 42| 5.36k|} igraph_marked_queue_int_size: 58| 66.2k|igraph_integer_t igraph_marked_queue_int_size(const igraph_marked_queue_int_t *q) { 59| 66.2k| return q->size; 60| 66.2k|} igraph_marked_queue_int_iselement: 63| 231k| igraph_integer_t elem) { 64| 231k| return (VECTOR(q->set)[elem] == q->mark); ------------------ | | 69| 231k|#define VECTOR(v) ((v).stor_begin) ------------------ 65| 231k|} igraph_marked_queue_int_push: 67| 15.0k|igraph_error_t igraph_marked_queue_int_push(igraph_marked_queue_int_t *q, igraph_integer_t elem) { 68| 15.0k| if (VECTOR(q->set)[elem] != q->mark) { ------------------ | | 69| 15.0k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (68:9): [True: 15.0k, False: 0] ------------------ 69| 15.0k| IGRAPH_CHECK(igraph_dqueue_int_push(&q->Q, elem)); ------------------ | | 752| 15.0k| do { \ | | 753| 15.0k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 15.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 15.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 15.0k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 15.0k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 70| 15.0k| VECTOR(q->set)[elem] = q->mark; ------------------ | | 69| 15.0k|#define VECTOR(v) ((v).stor_begin) ------------------ 71| 15.0k| q->size += 1; 72| 15.0k| } 73| 15.0k| return IGRAPH_SUCCESS; 74| 15.0k|} igraph_marked_queue_int_start_batch: 76| 13.8k|igraph_error_t igraph_marked_queue_int_start_batch(igraph_marked_queue_int_t *q) { 77| 13.8k| IGRAPH_CHECK(igraph_dqueue_int_push(&q->Q, BATCH_MARKER)); ------------------ | | 752| 13.8k| do { \ | | 753| 13.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 13.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 13.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 78| 13.8k| return IGRAPH_SUCCESS; 79| 13.8k|} igraph_marked_queue_int_pop_back_batch: 81| 13.8k|void igraph_marked_queue_int_pop_back_batch(igraph_marked_queue_int_t *q) { 82| 13.8k| igraph_integer_t size = igraph_dqueue_int_size(&q->Q); 83| 13.8k| igraph_integer_t elem; 84| 28.9k| while (size > 0 && ------------------ | Branch (84:12): [True: 28.9k, False: 0] ------------------ 85| 28.9k| (elem = igraph_dqueue_int_pop_back(&q->Q)) != BATCH_MARKER) { ------------------ | | 26| 28.9k|#define BATCH_MARKER -1 ------------------ | Branch (85:12): [True: 15.0k, False: 13.8k] ------------------ 86| 15.0k| VECTOR(q->set)[elem] = 0; ------------------ | | 69| 15.0k|#define VECTOR(v) ((v).stor_begin) ------------------ 87| 15.0k| size--; 88| 15.0k| q->size--; 89| 15.0k| } 90| 13.8k|} igraph_marked_queue_int_as_vector: 105| 13.8k| igraph_vector_int_t *vec) { 106| 13.8k| igraph_integer_t i, p, n = igraph_dqueue_int_size(&q->Q); 107| 13.8k| IGRAPH_CHECK(igraph_vector_int_resize(vec, q->size)); ------------------ | | 752| 13.8k| do { \ | | 753| 13.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 13.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 13.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 108| 97.8k| for (i = 0, p = 0; i < n; i++) { ------------------ | Branch (108:24): [True: 83.9k, False: 13.8k] ------------------ 109| 83.9k| igraph_integer_t e = igraph_dqueue_int_get(&q->Q, i); 110| 83.9k| if (e != BATCH_MARKER) { ------------------ | | 26| 83.9k|#define BATCH_MARKER -1 ------------------ | Branch (110:13): [True: 43.9k, False: 40.0k] ------------------ 111| 43.9k| VECTOR(*vec)[p++] = e; ------------------ | | 69| 43.9k|#define VECTOR(v) ((v).stor_begin) ------------------ 112| 43.9k| } 113| 83.9k| } 114| 13.8k| return IGRAPH_SUCCESS; 115| 13.8k|} igraph_free: 63| 6.07k|void igraph_free(void *ptr) { 64| 6.07k| IGRAPH_FREE(ptr); ------------------ | | 35| 6.07k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 65| 6.07k|} igraph_progress: 55| 10.7k|igraph_error_t igraph_progress(const char *message, igraph_real_t percent, void *data) { 56| 10.7k| if (igraph_i_progress_handler) { ------------------ | Branch (56:9): [True: 0, False: 10.7k] ------------------ 57| 0| if (igraph_i_progress_handler(message, percent, data) != IGRAPH_SUCCESS) { ------------------ | Branch (57:13): [True: 0, False: 0] ------------------ 58| 0| return IGRAPH_INTERRUPTED; 59| 0| } 60| 0| } 61| 10.7k| return IGRAPH_SUCCESS; 62| 10.7k|} igraph_stack_int_init: 45| 5.76k|igraph_error_t FUNCTION(igraph_stack, init)(TYPE(igraph_stack)* s, igraph_integer_t capacity) { 46| 5.76k| igraph_integer_t alloc_size; 47| 5.76k| IGRAPH_ASSERT(capacity >= 0); ------------------ | | 1107| 5.76k| do { \ | | 1108| 5.76k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 5.76k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.76k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 5.76k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 48| 5.76k| alloc_size = capacity > 0 ? capacity : 1; ------------------ | Branch (48:18): [True: 402, False: 5.36k] ------------------ 49| 5.76k| IGRAPH_ASSERT(s != NULL); ------------------ | | 1107| 5.76k| do { \ | | 1108| 5.76k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 5.76k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.76k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 5.76k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 50| 5.76k| s->stor_begin = IGRAPH_CALLOC(alloc_size, BASE); ------------------ | | 32| 5.76k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [True: 5.76k, False: 0] | | ------------------ ------------------ 51| 5.76k| if (s->stor_begin == NULL) { ------------------ | Branch (51:9): [True: 0, False: 5.76k] ------------------ 52| 0| IGRAPH_ERROR("Cannot initialize stack.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 53| 0| } 54| 5.76k| s->stor_end = s->stor_begin + alloc_size; 55| 5.76k| s->end = s->stor_begin; 56| | 57| 5.76k| return IGRAPH_SUCCESS; 58| 5.76k|} igraph_stack_int_destroy: 73| 5.76k|void FUNCTION(igraph_stack, destroy) (TYPE(igraph_stack)* s) { 74| 5.76k| IGRAPH_ASSERT(s != NULL); ------------------ | | 1107| 5.76k| do { \ | | 1108| 5.76k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 5.76k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.76k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 5.76k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 75| 5.76k| if (s->stor_begin != NULL) { ------------------ | Branch (75:9): [True: 5.76k, False: 0] ------------------ 76| 5.76k| IGRAPH_FREE(s->stor_begin); ------------------ | | 35| 5.76k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 77| 5.76k| s->stor_begin = NULL; 78| 5.76k| } 79| 5.76k|} igraph_stack_int_capacity: 99| 533|igraph_integer_t FUNCTION(igraph_stack, capacity)(const TYPE(igraph_stack) *s) { 100| 533| return s->stor_end - s->stor_begin; 101| 533|} igraph_stack_int_reserve: 119| 533|igraph_error_t FUNCTION(igraph_stack, reserve)(TYPE(igraph_stack)* s, igraph_integer_t capacity) { 120| 533| igraph_integer_t current_capacity; 121| 533| BASE *tmp; ------------------ | | 71| 533| #define BASE igraph_integer_t ------------------ 122| | 123| 533| IGRAPH_ASSERT(s != NULL); ------------------ | | 1107| 533| do { \ | | 1108| 533| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 533| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 533] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 533| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 124| 533| IGRAPH_ASSERT(s->stor_begin != NULL); ------------------ | | 1107| 533| do { \ | | 1108| 533| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 533| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 533] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 533| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 125| 533| IGRAPH_ASSERT(capacity >= 0); ------------------ | | 1107| 533| do { \ | | 1108| 533| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 533| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 533] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 533| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 126| | 127| 533| current_capacity = FUNCTION(igraph_stack, capacity)(s); ------------------ | | 169| 533| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 27| 533|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 533|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 128| | 129| 533| if (capacity <= current_capacity) { ------------------ | Branch (129:9): [True: 0, False: 533] ------------------ 130| 0| return IGRAPH_SUCCESS; 131| 0| } 132| | 133| 533| tmp = IGRAPH_REALLOC(s->stor_begin, capacity, BASE); ------------------ | | 34| 533|#define IGRAPH_REALLOC(p,n,t) (t*) realloc((void*)(p), (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1) | | ------------------ | | | Branch (34:56): [True: 533, False: 0] | | ------------------ ------------------ 134| 533| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for stack."); ------------------ | | 807| 533| do { \ | | 808| 533| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 533| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 533] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 533| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 135| | 136| 533| s->end = tmp + (s->end - s->stor_begin); 137| 533| s->stor_begin = tmp; 138| 533| s->stor_end = s->stor_begin + capacity; 139| | 140| 533| return IGRAPH_SUCCESS; 141| 533|} igraph_stack_int_empty: 155| 11.7k|igraph_bool_t FUNCTION(igraph_stack, empty)(TYPE(igraph_stack)* s) { 156| 11.7k| IGRAPH_ASSERT(s != NULL); ------------------ | | 1107| 11.7k| do { \ | | 1108| 11.7k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 11.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 11.7k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 11.7k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 157| 11.7k| IGRAPH_ASSERT(s->stor_begin != NULL); ------------------ | | 1107| 11.7k| do { \ | | 1108| 11.7k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 11.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 11.7k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 11.7k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 158| 11.7k| return s->stor_begin == s->end; 159| 11.7k|} igraph_stack_int_size: 172| 533|igraph_integer_t FUNCTION(igraph_stack, size)(const TYPE(igraph_stack)* s) { 173| 533| IGRAPH_ASSERT(s != NULL); ------------------ | | 1107| 533| do { \ | | 1108| 533| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 533| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 533] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 533| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 174| 533| IGRAPH_ASSERT(s->stor_begin != NULL); ------------------ | | 1107| 533| do { \ | | 1108| 533| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 533| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 533] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 533| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 175| 533| return s->end - s->stor_begin; 176| 533|} igraph_stack_int_push: 209| 16.1k|igraph_error_t FUNCTION(igraph_stack, push)(TYPE(igraph_stack)* s, BASE elem) { 210| 16.1k| IGRAPH_ASSERT(s != NULL); ------------------ | | 1107| 16.1k| do { \ | | 1108| 16.1k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 16.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 16.1k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 16.1k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 211| 16.1k| IGRAPH_ASSERT(s->stor_begin != NULL); ------------------ | | 1107| 16.1k| do { \ | | 1108| 16.1k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 16.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 16.1k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 16.1k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 212| | 213| 16.1k| if (s->stor_end == s->end) { ------------------ | Branch (213:9): [True: 533, False: 15.6k] ------------------ 214| | /* full, allocate more storage */ 215| 533| igraph_integer_t old_size = FUNCTION(igraph_stack, size)(s); ------------------ | | 169| 533| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 27| 533|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 533|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 216| 533| igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 78| 533|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 78| 533|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (216:37): [True: 533, False: 0] ------------------ 217| 533| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 78| 533|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (217:13): [True: 0, False: 533] ------------------ 218| 0| IGRAPH_ERROR("Cannot push to stack, already at maximum size.", IGRAPH_EOVERFLOW); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 219| 0| } 220| 533| if (new_size == 0) { ------------------ | Branch (220:13): [True: 0, False: 533] ------------------ 221| 0| new_size = 1; 222| 0| } 223| 533| IGRAPH_CHECK(FUNCTION(igraph_stack, reserve)(s, new_size)); ------------------ | | 752| 533| do { \ | | 753| 533| igraph_error_t igraph_i_ret = (expr); \ | | 754| 533| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 533| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 533] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 533| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 224| 533| } 225| | 226| 16.1k| *(s->end) = elem; 227| 16.1k| s->end += 1; 228| | 229| 16.1k| return IGRAPH_SUCCESS; 230| 16.1k|} igraph_stack_int_pop: 245| 15.1k|BASE FUNCTION(igraph_stack, pop)(TYPE(igraph_stack)* s) { 246| 15.1k| IGRAPH_ASSERT(s != NULL); ------------------ | | 1107| 15.1k| do { \ | | 1108| 15.1k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 15.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 15.1k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 15.1k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 247| 15.1k| IGRAPH_ASSERT(s->stor_begin != NULL); ------------------ | | 1107| 15.1k| do { \ | | 1108| 15.1k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 15.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 15.1k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 15.1k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 248| 15.1k| IGRAPH_ASSERT(s->end != NULL); ------------------ | | 1107| 15.1k| do { \ | | 1108| 15.1k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 15.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 15.1k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 15.1k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 249| 15.1k| IGRAPH_ASSERT(s->end != s->stor_begin); ------------------ | | 1107| 15.1k| do { \ | | 1108| 15.1k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 15.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 15.1k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 15.1k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 250| | 251| 15.1k| (s->end)--; 252| | 253| 15.1k| return *(s->end); 254| 15.1k|} igraph_stack_int_top: 269| 11.3k|BASE FUNCTION(igraph_stack, top)(const TYPE(igraph_stack)* s) { 270| 11.3k| IGRAPH_ASSERT(s != NULL); ------------------ | | 1107| 11.3k| do { \ | | 1108| 11.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 11.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 11.3k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 11.3k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 271| 11.3k| IGRAPH_ASSERT(s->stor_begin != NULL); ------------------ | | 1107| 11.3k| do { \ | | 1108| 11.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 11.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 11.3k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 11.3k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 272| 11.3k| IGRAPH_ASSERT(s->end != NULL); ------------------ | | 1107| 11.3k| do { \ | | 1108| 11.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 11.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 11.3k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 11.3k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 273| 11.3k| IGRAPH_ASSERT(s->end != s->stor_begin); ------------------ | | 1107| 11.3k| do { \ | | 1108| 11.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 11.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 11.3k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 11.3k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 274| | 275| 11.3k| return *(s->end - 1); 276| 11.3k|} igraph_vector_int_list_init: 105| 18.4k|igraph_error_t FUNCTION(init)(TYPE* v, igraph_integer_t size) { 106| 18.4k| igraph_integer_t alloc_size = size > 0 ? size : 1; ------------------ | Branch (106:35): [True: 0, False: 18.4k] ------------------ 107| 18.4k| IGRAPH_ASSERT(size >= 0); ------------------ | | 1107| 18.4k| do { \ | | 1108| 18.4k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 18.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 18.4k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 18.4k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 108| 18.4k| v->stor_begin = IGRAPH_CALLOC(alloc_size, ITEM_TYPE); ------------------ | | 32| 18.4k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [True: 18.4k, False: 0] | | ------------------ ------------------ 109| 18.4k| if (v->stor_begin == 0) { ------------------ | Branch (109:9): [True: 0, False: 18.4k] ------------------ 110| 0| IGRAPH_ERROR("Cannot initialize list.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 111| 0| } 112| 18.4k| v->stor_end = v->stor_begin + alloc_size; 113| 18.4k| v->end = v->stor_begin + size; 114| | 115| 18.4k| IGRAPH_CHECK(INTERNAL_FUNCTION(init_slice)(v, v->stor_begin, v->end)); ------------------ | | 752| 18.4k| do { \ | | 753| 18.4k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 18.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 18.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 18.4k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 18.4k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 116| | 117| 18.4k| return IGRAPH_SUCCESS; 118| 18.4k|} igraph_vector_int_list_destroy: 140| 18.4k|void FUNCTION(destroy)(TYPE* v) { 141| 18.4k| IGRAPH_ASSERT(v != 0); ------------------ | | 1107| 18.4k| do { \ | | 1108| 18.4k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 18.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 18.4k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 18.4k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 142| | 143| 18.4k| if (v->stor_begin != 0) { ------------------ | Branch (143:9): [True: 18.4k, False: 0] ------------------ 144| 18.4k| FUNCTION(clear)(v); ------------------ | | 135| 18.4k| #define FUNCTION(c) CONCAT4(igraph_vector,SHORT,list,c) | | ------------------ | | | | 29| 18.4k|#define CONCAT4(a,b,c,d) CONCAT4x(a,b,c,d) | | | | ------------------ | | | | | | 28| 18.4k|#define CONCAT4x(a,b,c,d) a ## _ ## b ## _ ## c ## _ ## d | | | | ------------------ | | ------------------ ------------------ 145| 18.4k| IGRAPH_FREE(v->stor_begin); ------------------ | | 35| 18.4k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 146| 18.4k| v->stor_begin = NULL; 147| 18.4k| } 148| 18.4k|} igraph_vector_int_list_capacity: 167| 22.2k|igraph_integer_t FUNCTION(capacity)(const TYPE* v) { 168| 22.2k| return v->stor_end - v->stor_begin; 169| 22.2k|} igraph_vector_int_list_reserve: 197| 22.2k|igraph_error_t FUNCTION(reserve)(TYPE* v, igraph_integer_t capacity) { 198| 22.2k| igraph_integer_t current_capacity; 199| 22.2k| ITEM_TYPE *tmp; ------------------ | | 32| 22.2k| #define ITEM_TYPE BASE_VECTOR | | ------------------ | | | | 72| 22.2k| #define BASE_VECTOR igraph_vector_int_t | | ------------------ ------------------ 200| | 201| 22.2k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 22.2k| do { \ | | 1108| 22.2k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 22.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 22.2k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 22.2k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 202| 22.2k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 22.2k| do { \ | | 1108| 22.2k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 22.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 22.2k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 22.2k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 203| 22.2k| IGRAPH_ASSERT(capacity >= 0); ------------------ | | 1107| 22.2k| do { \ | | 1108| 22.2k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 22.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 22.2k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 22.2k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 204| | 205| 22.2k| current_capacity = FUNCTION(capacity)(v); ------------------ | | 135| 22.2k| #define FUNCTION(c) CONCAT4(igraph_vector,SHORT,list,c) | | ------------------ | | | | 29| 22.2k|#define CONCAT4(a,b,c,d) CONCAT4x(a,b,c,d) | | | | ------------------ | | | | | | 28| 22.2k|#define CONCAT4x(a,b,c,d) a ## _ ## b ## _ ## c ## _ ## d | | | | ------------------ | | ------------------ ------------------ 206| | 207| 22.2k| if (capacity <= current_capacity) { ------------------ | Branch (207:9): [True: 6.67k, False: 15.5k] ------------------ 208| 6.67k| return IGRAPH_SUCCESS; 209| 6.67k| } 210| | 211| 15.5k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, ITEM_TYPE); ------------------ | | 34| 15.5k|#define IGRAPH_REALLOC(p,n,t) (t*) realloc((void*)(p), (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1) | | ------------------ | | | Branch (34:56): [True: 15.5k, False: 0] | | ------------------ ------------------ 212| 15.5k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for list."); ------------------ | | 807| 15.5k| do { \ | | 808| 15.5k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 15.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 15.5k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 15.5k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 213| | 214| 15.5k| v->end = tmp + (v->end - v->stor_begin); 215| 15.5k| v->stor_begin = tmp; 216| 15.5k| v->stor_end = v->stor_begin + capacity; 217| | 218| 15.5k| return IGRAPH_SUCCESS; 219| 15.5k|} igraph_vector_int_list_empty: 233| 19.2k|igraph_bool_t FUNCTION(empty)(const TYPE* v) { 234| 19.2k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 19.2k| do { \ | | 1108| 19.2k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 19.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 19.2k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 19.2k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 235| 19.2k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 19.2k| do { \ | | 1108| 19.2k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 19.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 19.2k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 19.2k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 236| 19.2k| return v->stor_begin == v->end; 237| 19.2k|} igraph_vector_int_list_size: 250| 379k|igraph_integer_t FUNCTION(size)(const TYPE* v) { 251| 379k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 379k| do { \ | | 1108| 379k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 379k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 379k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 379k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 252| 379k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 379k| do { \ | | 1108| 379k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 379k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 379k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 379k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 253| 379k| return v->end - v->stor_begin; 254| 379k|} igraph_vector_int_list_resize: 287| 212|igraph_error_t FUNCTION(resize)(TYPE* v, igraph_integer_t new_size) { 288| 212| igraph_integer_t old_size; 289| | 290| 212| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 212| do { \ | | 1108| 212| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 212| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 212] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 212| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 291| 212| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 212| do { \ | | 1108| 212| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 212| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 212] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 212| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 292| | 293| 212| IGRAPH_CHECK(FUNCTION(reserve)(v, new_size)); ------------------ | | 752| 212| do { \ | | 753| 212| igraph_error_t igraph_i_ret = (expr); \ | | 754| 212| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 212| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 212] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 212| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 294| | 295| 212| old_size = FUNCTION(size)(v); ------------------ | | 135| 212| #define FUNCTION(c) CONCAT4(igraph_vector,SHORT,list,c) | | ------------------ | | | | 29| 212|#define CONCAT4(a,b,c,d) CONCAT4x(a,b,c,d) | | | | ------------------ | | | | | | 28| 212|#define CONCAT4x(a,b,c,d) a ## _ ## b ## _ ## c ## _ ## d | | | | ------------------ | | ------------------ ------------------ 296| | 297| 212| if (old_size < new_size) { ------------------ | Branch (297:9): [True: 171, False: 41] ------------------ 298| 171| IGRAPH_CHECK(INTERNAL_FUNCTION(init_slice)(v, v->stor_begin + old_size, v->stor_begin + new_size)); ------------------ | | 752| 171| do { \ | | 753| 171| igraph_error_t igraph_i_ret = (expr); \ | | 754| 171| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 171| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 171] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 171| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 299| 171| } else if (old_size > new_size) { ------------------ | Branch (299:16): [True: 0, False: 41] ------------------ 300| 0| INTERNAL_FUNCTION(destroy_slice)(v, v->stor_begin + new_size, v->stor_begin + old_size); ------------------ | | 136| 0| #define INTERNAL_FUNCTION(c) CONCAT4(igraph_i_vector,SHORT,list,c) | | ------------------ | | | | 29| 0|#define CONCAT4(a,b,c,d) CONCAT4x(a,b,c,d) | | | | ------------------ | | | | | | 28| 0|#define CONCAT4x(a,b,c,d) a ## _ ## b ## _ ## c ## _ ## d | | | | ------------------ | | ------------------ ------------------ 301| 0| } 302| | 303| 212| v->end = v->stor_begin + new_size; 304| | 305| 212| return IGRAPH_SUCCESS; 306| 212|} igraph_vector_int_list_clear: 321| 31.4k|void FUNCTION(clear)(TYPE* v) { 322| 31.4k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 31.4k| do { \ | | 1108| 31.4k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 31.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 31.4k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 31.4k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 323| 31.4k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 31.4k| do { \ | | 1108| 31.4k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 31.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 31.4k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 31.4k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 324| 31.4k| INTERNAL_FUNCTION(destroy_slice)(v, v->stor_begin, v->end); ------------------ | | 136| 31.4k| #define INTERNAL_FUNCTION(c) CONCAT4(igraph_i_vector,SHORT,list,c) | | ------------------ | | | | 29| 31.4k|#define CONCAT4(a,b,c,d) CONCAT4x(a,b,c,d) | | | | ------------------ | | | | | | 28| 31.4k|#define CONCAT4x(a,b,c,d) a ## _ ## b ## _ ## c ## _ ## d | | | | ------------------ | | ------------------ ------------------ 325| 31.4k| v->end = v->stor_begin; 326| 31.4k|} igraph_vector_int_list_get_ptr: 340| 6.83M|ITEM_TYPE* FUNCTION(get_ptr)(const TYPE* v, igraph_integer_t pos) { 341| 6.83M| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 6.83M| do { \ | | 1108| 6.83M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 6.83M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 6.83M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 6.83M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 342| 6.83M| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 6.83M| do { \ | | 1108| 6.83M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 6.83M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 6.83M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 6.83M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 343| 6.83M| return v->stor_begin + pos; 344| 6.83M|} igraph_vector_int_list_tail_ptr: 448| 13.8k|ITEM_TYPE* FUNCTION(tail_ptr)(const TYPE *v) { 449| 13.8k| igraph_integer_t size = FUNCTION(size)(v); ------------------ | | 135| 13.8k| #define FUNCTION(c) CONCAT4(igraph_vector,SHORT,list,c) | | ------------------ | | | | 29| 13.8k|#define CONCAT4(a,b,c,d) CONCAT4x(a,b,c,d) | | | | ------------------ | | | | | | 28| 13.8k|#define CONCAT4x(a,b,c,d) a ## _ ## b ## _ ## c ## _ ## d | | | | ------------------ | | ------------------ ------------------ 450| 13.8k| return size > 0 ? FUNCTION(get_ptr)(v, size - 1) : 0; ------------------ | | 135| 13.8k| #define FUNCTION(c) CONCAT4(igraph_vector,SHORT,list,c) | | ------------------ | | | | 29| 13.8k|#define CONCAT4(a,b,c,d) CONCAT4x(a,b,c,d) | | | | ------------------ | | | | | | 28| 13.8k|#define CONCAT4x(a,b,c,d) a ## _ ## b ## _ ## c ## _ ## d | | | | ------------------ | | ------------------ ------------------ | Branch (450:12): [True: 13.8k, False: 0] ------------------ 451| 13.8k|} igraph_vector_int_list_discard_back: 493| 13.8k|void FUNCTION(discard_back)(TYPE* v) { 494| 13.8k| igraph_integer_t size = FUNCTION(size)(v); ------------------ | | 135| 13.8k| #define FUNCTION(c) CONCAT4(igraph_vector,SHORT,list,c) | | ------------------ | | | | 29| 13.8k|#define CONCAT4(a,b,c,d) CONCAT4x(a,b,c,d) | | | | ------------------ | | | | | | 28| 13.8k|#define CONCAT4x(a,b,c,d) a ## _ ## b ## _ ## c ## _ ## d | | | | ------------------ | | ------------------ ------------------ 495| 13.8k| if (size > 0) { ------------------ | Branch (495:9): [True: 13.8k, False: 0] ------------------ 496| 13.8k| INTERNAL_FUNCTION(destroy_item)(v->end - 1); ------------------ | | 136| 13.8k| #define INTERNAL_FUNCTION(c) CONCAT4(igraph_i_vector,SHORT,list,c) | | ------------------ | | | | 29| 13.8k|#define CONCAT4(a,b,c,d) CONCAT4x(a,b,c,d) | | | | ------------------ | | | | | | 28| 13.8k|#define CONCAT4x(a,b,c,d) a ## _ ## b ## _ ## c ## _ ## d | | | | ------------------ | | ------------------ ------------------ 497| 13.8k| v->end -= 1; 498| 13.8k| } 499| 13.8k|} igraph_vector_int_list_push_back: 555| 56.1k|igraph_error_t FUNCTION(push_back)(TYPE* v, ITEM_TYPE* e) { 556| 56.1k| IGRAPH_CHECK(INTERNAL_FUNCTION(expand_if_full)(v)); ------------------ | | 752| 56.1k| do { \ | | 753| 56.1k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 56.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 56.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 56.1k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 56.1k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 557| 56.1k| *(v->end) = *e; 558| 56.1k| v->end += 1; 559| 56.1k| return IGRAPH_SUCCESS; 560| 56.1k|} igraph_vector_int_list_push_back_copy: 581| 56.1k|igraph_error_t FUNCTION(push_back_copy)(TYPE* v, const ITEM_TYPE* e) { 582| 56.1k| ITEM_TYPE copy; ------------------ | | 32| 56.1k| #define ITEM_TYPE BASE_VECTOR | | ------------------ | | | | 72| 56.1k| #define BASE_VECTOR igraph_vector_int_t | | ------------------ ------------------ 583| 56.1k| IGRAPH_CHECK(INTERNAL_FUNCTION(copy_item)(©, e)); ------------------ | | 752| 56.1k| do { \ | | 753| 56.1k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 56.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 56.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 56.1k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 56.1k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 584| 56.1k| IGRAPH_FINALLY(INTERNAL_FUNCTION(destroy_item), ©); ------------------ | | 695| 56.1k| do { \ | | 696| 56.1k| /* the following branch makes the compiler check the compatibility of \ | | 697| 56.1k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 56.1k| * incorrect destructor function with the pointer */ \ | | 699| 56.1k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 56.1k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 56.1k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 585| 56.1k| IGRAPH_CHECK(FUNCTION(push_back)(v, ©)); ------------------ | | 752| 56.1k| do { \ | | 753| 56.1k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 56.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 56.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 56.1k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 56.1k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 586| 56.1k| IGRAPH_FINALLY_CLEAN(1); 587| 56.1k| return IGRAPH_SUCCESS; 588| 56.1k|} igraph_vector_int_list_push_back_new: 610| 27.6k|igraph_error_t FUNCTION(push_back_new)(TYPE* v, ITEM_TYPE** e) { 611| 27.6k| IGRAPH_CHECK(INTERNAL_FUNCTION(expand_if_full)(v)); ------------------ | | 752| 27.6k| do { \ | | 753| 27.6k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 27.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 27.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 27.6k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 27.6k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 612| 27.6k| IGRAPH_CHECK(INTERNAL_FUNCTION(init_item)(v, v->end)); ------------------ | | 752| 27.6k| do { \ | | 753| 27.6k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 27.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 27.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 27.6k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 27.6k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 613| 27.6k| if (e) { ------------------ | Branch (613:9): [True: 27.6k, False: 0] ------------------ 614| 27.6k| *e = v->end; 615| 27.6k| } 616| 27.6k| v->end += 1; 617| 27.6k| return IGRAPH_SUCCESS; 618| 27.6k|} igraph_vector_int_list_reverse: 1011| 5.36k|igraph_error_t FUNCTION(reverse)(TYPE *v) { 1012| 5.36k| igraph_integer_t n = FUNCTION(size)(v), n2 = n / 2; ------------------ | | 135| 5.36k| #define FUNCTION(c) CONCAT4(igraph_vector,SHORT,list,c) | | ------------------ | | | | 29| 5.36k|#define CONCAT4(a,b,c,d) CONCAT4x(a,b,c,d) | | | | ------------------ | | | | | | 28| 5.36k|#define CONCAT4x(a,b,c,d) a ## _ ## b ## _ ## c ## _ ## d | | | | ------------------ | | ------------------ ------------------ 1013| 5.36k| igraph_integer_t i, j; 1014| 10.3k| for (i = 0, j = n - 1; i < n2; i++, j--) { ------------------ | Branch (1014:28): [True: 5.02k, False: 5.36k] ------------------ 1015| 5.02k| ITEM_TYPE tmp; ------------------ | | 32| 5.02k| #define ITEM_TYPE BASE_VECTOR | | ------------------ | | | | 72| 5.02k| #define BASE_VECTOR igraph_vector_int_t | | ------------------ ------------------ 1016| 5.02k| tmp = VECTOR(*v)[i]; ------------------ | | 69| 5.02k|#define VECTOR(v) ((v).stor_begin) ------------------ 1017| 5.02k| VECTOR(*v)[i] = VECTOR(*v)[j]; ------------------ | | 69| 5.02k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*v)[i] = VECTOR(*v)[j]; ------------------ | | 69| 5.02k|#define VECTOR(v) ((v).stor_begin) ------------------ 1018| 5.02k| VECTOR(*v)[j] = tmp; ------------------ | | 69| 5.02k|#define VECTOR(v) ((v).stor_begin) ------------------ 1019| 5.02k| } 1020| 5.36k| return IGRAPH_SUCCESS; 1021| 5.36k|} vector_list.c:igraph_i_vector_int_list_init_item: 1027| 28.0k|static igraph_error_t INTERNAL_FUNCTION(init_item)(const TYPE* list, ITEM_TYPE* item) { 1028| 28.0k| IGRAPH_UNUSED(list); ------------------ | | 12| 28.0k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 1029| 28.0k| return ITEM_FUNCTION(init)(item, 0); ------------------ | | 43| 28.0k| #define ITEM_FUNCTION(f) CONCAT3(igraph_vector,SHORT,f) | | ------------------ | | | | 27| 28.0k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 28.0k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 1030| 28.0k|} vector_list.c:igraph_i_vector_int_list_copy_item: 1032| 56.1k|static igraph_error_t INTERNAL_FUNCTION(copy_item)(ITEM_TYPE* dest, const ITEM_TYPE* source) { 1033| 56.1k| return ITEM_FUNCTION(init_copy)(dest, source); ------------------ | | 43| 56.1k| #define ITEM_FUNCTION(f) CONCAT3(igraph_vector,SHORT,f) | | ------------------ | | | | 27| 56.1k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 56.1k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 1034| 56.1k|} vector_list.c:igraph_i_vector_int_list_destroy_item: 1036| 84.2k|static void INTERNAL_FUNCTION(destroy_item)(ITEM_TYPE* item) { 1037| 84.2k| ITEM_FUNCTION(destroy)(item); ------------------ | | 43| 84.2k| #define ITEM_FUNCTION(f) CONCAT3(igraph_vector,SHORT,f) | | ------------------ | | | | 27| 84.2k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 84.2k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 1038| 84.2k|} vector_list.c:igraph_i_vector_int_list_init_slice: 1044| 18.5k|static igraph_error_t INTERNAL_FUNCTION(init_slice)(const TYPE* list, ITEM_TYPE* start, ITEM_TYPE* end) { 1045| 18.5k| ITEM_TYPE* current; ------------------ | | 32| 18.5k| #define ITEM_TYPE BASE_VECTOR | | ------------------ | | | | 72| 18.5k| #define BASE_VECTOR igraph_vector_int_t | | ------------------ ------------------ 1046| 18.5k| igraph_error_t retval; 1047| | 1048| 19.0k| for (current = start; current < end; current++) { ------------------ | Branch (1048:27): [True: 424, False: 18.5k] ------------------ 1049| 424| retval = INTERNAL_FUNCTION(init_item)(list, current); ------------------ | | 136| 424| #define INTERNAL_FUNCTION(c) CONCAT4(igraph_i_vector,SHORT,list,c) | | ------------------ | | | | 29| 424|#define CONCAT4(a,b,c,d) CONCAT4x(a,b,c,d) | | | | ------------------ | | | | | | 28| 424|#define CONCAT4x(a,b,c,d) a ## _ ## b ## _ ## c ## _ ## d | | | | ------------------ | | ------------------ ------------------ 1050| 424| if (retval) { ------------------ | Branch (1050:13): [True: 0, False: 424] ------------------ 1051| 0| INTERNAL_FUNCTION(destroy_slice)(list, start, current); ------------------ | | 136| 0| #define INTERNAL_FUNCTION(c) CONCAT4(igraph_i_vector,SHORT,list,c) | | ------------------ | | | | 29| 0|#define CONCAT4(a,b,c,d) CONCAT4x(a,b,c,d) | | | | ------------------ | | | | | | 28| 0|#define CONCAT4x(a,b,c,d) a ## _ ## b ## _ ## c ## _ ## d | | | | ------------------ | | ------------------ ------------------ 1052| 0| IGRAPH_CHECK(retval); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1053| 0| } 1054| 424| } 1055| | 1056| 18.5k| return IGRAPH_SUCCESS; 1057| 18.5k|} vector_list.c:igraph_i_vector_int_list_destroy_slice: 1059| 31.4k|static void INTERNAL_FUNCTION(destroy_slice)(const TYPE* list, ITEM_TYPE* start, ITEM_TYPE* end) { 1060| 31.4k| IGRAPH_UNUSED(list); ------------------ | | 12| 31.4k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 1061| 101k| for (; start < end; start++) { ------------------ | Branch (1061:12): [True: 70.3k, False: 31.4k] ------------------ 1062| 70.3k| INTERNAL_FUNCTION(destroy_item)(start); ------------------ | | 136| 70.3k| #define INTERNAL_FUNCTION(c) CONCAT4(igraph_i_vector,SHORT,list,c) | | ------------------ | | | | 29| 70.3k|#define CONCAT4(a,b,c,d) CONCAT4x(a,b,c,d) | | | | ------------------ | | | | | | 28| 70.3k|#define CONCAT4x(a,b,c,d) a ## _ ## b ## _ ## c ## _ ## d | | | | ------------------ | | ------------------ ------------------ 1063| 70.3k| } 1064| 31.4k|} vector_list.c:igraph_i_vector_int_list_expand_if_full: 1070| 83.7k|static igraph_error_t INTERNAL_FUNCTION(expand_if_full)(TYPE* v) { 1071| 83.7k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 83.7k| do { \ | | 1108| 83.7k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 83.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 83.7k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 83.7k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1072| 83.7k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 83.7k| do { \ | | 1108| 83.7k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 83.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 83.7k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 83.7k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1073| | 1074| 83.7k| if (v->stor_end == v->end) { ------------------ | Branch (1074:9): [True: 11.2k, False: 72.4k] ------------------ 1075| 11.2k| igraph_integer_t old_size = FUNCTION(size)(v); ------------------ | | 135| 11.2k| #define FUNCTION(c) CONCAT4(igraph_vector,SHORT,list,c) | | ------------------ | | | | 29| 11.2k|#define CONCAT4(a,b,c,d) CONCAT4x(a,b,c,d) | | | | ------------------ | | | | | | 28| 11.2k|#define CONCAT4x(a,b,c,d) a ## _ ## b ## _ ## c ## _ ## d | | | | ------------------ | | ------------------ ------------------ 1076| 11.2k| igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 78| 11.2k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 78| 11.2k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (1076:37): [True: 11.2k, False: 0] ------------------ 1077| 11.2k| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 78| 11.2k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (1077:13): [True: 0, False: 11.2k] ------------------ 1078| 0| IGRAPH_ERROR("Cannot add new item to list, already at maximum size.", IGRAPH_EOVERFLOW); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1079| 0| } 1080| 11.2k| if (new_size == 0) { ------------------ | Branch (1080:13): [True: 0, False: 11.2k] ------------------ 1081| 0| new_size = 1; 1082| 0| } 1083| 11.2k| IGRAPH_CHECK(FUNCTION(reserve)(v, new_size)); ------------------ | | 752| 11.2k| do { \ | | 753| 11.2k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 11.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 11.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 11.2k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 11.2k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1084| 11.2k| } 1085| | 1086| 83.7k| return IGRAPH_SUCCESS; 1087| 83.7k|} igraph_vector_int_pair_order: 139| 188k| igraph_vector_int_t* res, igraph_integer_t nodes) { 140| 188k| igraph_integer_t edges = igraph_vector_int_size(v); 141| 188k| igraph_vector_int_t ptr; 142| 188k| igraph_vector_int_t rad; 143| 188k| igraph_integer_t i, j; 144| | 145| 188k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 188k| do { \ | | 1108| 188k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 188k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 188k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 188k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 146| 188k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 188k| do { \ | | 1108| 188k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 188k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 188k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 188k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 147| | 148| 188k| IGRAPH_VECTOR_INT_INIT_FINALLY(&ptr, nodes + 1); ------------------ | | 124| 188k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 188k| do { \ | | | | 753| 188k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 188k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 188k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 188k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 188k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 188k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 188k| do { \ | | | | 696| 188k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 188k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 188k| * incorrect destructor function with the pointer */ \ | | | | 699| 188k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 188k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 188k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 149| 188k| IGRAPH_VECTOR_INT_INIT_FINALLY(&rad, edges); ------------------ | | 124| 188k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 188k| do { \ | | | | 753| 188k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 188k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 188k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 188k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 188k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 188k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 188k| do { \ | | | | 696| 188k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 188k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 188k| * incorrect destructor function with the pointer */ \ | | | | 699| 188k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 188k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 188k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 150| 188k| IGRAPH_CHECK(igraph_vector_int_resize(res, edges)); ------------------ | | 752| 188k| do { \ | | 753| 188k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 188k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 188k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 188k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 188k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 151| | 152| 6.44M| for (i = 0; i < edges; i++) { ------------------ | Branch (152:17): [True: 6.25M, False: 188k] ------------------ 153| 6.25M| igraph_integer_t radix = VECTOR(*v2)[i]; ------------------ | | 69| 6.25M|#define VECTOR(v) ((v).stor_begin) ------------------ 154| 6.25M| if (VECTOR(ptr)[radix] != 0) { ------------------ | | 69| 6.25M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (154:13): [True: 3.91M, False: 2.33M] ------------------ 155| 3.91M| VECTOR(rad)[i] = VECTOR(ptr)[radix]; ------------------ | | 69| 3.91M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(rad)[i] = VECTOR(ptr)[radix]; ------------------ | | 69| 3.91M|#define VECTOR(v) ((v).stor_begin) ------------------ 156| 3.91M| } 157| 6.25M| VECTOR(ptr)[radix] = i + 1; ------------------ | | 69| 6.25M|#define VECTOR(v) ((v).stor_begin) ------------------ 158| 6.25M| } 159| | 160| 188k| j = 0; 161| 2.98M| for (i = 0; i < nodes + 1; i++) { ------------------ | Branch (161:17): [True: 2.79M, False: 188k] ------------------ 162| 2.79M| if (VECTOR(ptr)[i] != 0) { ------------------ | | 69| 2.79M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (162:13): [True: 2.33M, False: 463k] ------------------ 163| 2.33M| igraph_integer_t next = VECTOR(ptr)[i] - 1; ------------------ | | 69| 2.33M|#define VECTOR(v) ((v).stor_begin) ------------------ 164| 2.33M| VECTOR(*res)[j++] = next; ------------------ | | 69| 2.33M|#define VECTOR(v) ((v).stor_begin) ------------------ 165| 6.25M| while (VECTOR(rad)[next] != 0) { ------------------ | | 69| 6.25M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (165:20): [True: 3.91M, False: 2.33M] ------------------ 166| 3.91M| next = VECTOR(rad)[next] - 1; ------------------ | | 69| 3.91M|#define VECTOR(v) ((v).stor_begin) ------------------ 167| 3.91M| VECTOR(*res)[j++] = next; ------------------ | | 69| 3.91M|#define VECTOR(v) ((v).stor_begin) ------------------ 168| 3.91M| } 169| 2.33M| } 170| 2.79M| } 171| | 172| 188k| igraph_vector_int_null(&ptr); 173| 188k| igraph_vector_int_null(&rad); 174| | 175| 6.44M| for (i = 0; i < edges; i++) { ------------------ | Branch (175:17): [True: 6.25M, False: 188k] ------------------ 176| 6.25M| igraph_integer_t edge = VECTOR(*res)[edges - i - 1]; ------------------ | | 69| 6.25M|#define VECTOR(v) ((v).stor_begin) ------------------ 177| 6.25M| igraph_integer_t radix = VECTOR(*v)[edge]; ------------------ | | 69| 6.25M|#define VECTOR(v) ((v).stor_begin) ------------------ 178| 6.25M| if (VECTOR(ptr)[radix] != 0) { ------------------ | | 69| 6.25M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (178:13): [True: 3.91M, False: 2.33M] ------------------ 179| 3.91M| VECTOR(rad)[edge] = VECTOR(ptr)[radix]; ------------------ | | 69| 3.91M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(rad)[edge] = VECTOR(ptr)[radix]; ------------------ | | 69| 3.91M|#define VECTOR(v) ((v).stor_begin) ------------------ 180| 3.91M| } 181| 6.25M| VECTOR(ptr)[radix] = edge + 1; ------------------ | | 69| 6.25M|#define VECTOR(v) ((v).stor_begin) ------------------ 182| 6.25M| } 183| | 184| 188k| j = 0; 185| 2.98M| for (i = 0; i < nodes + 1; i++) { ------------------ | Branch (185:17): [True: 2.79M, False: 188k] ------------------ 186| 2.79M| if (VECTOR(ptr)[i] != 0) { ------------------ | | 69| 2.79M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (186:13): [True: 2.33M, False: 463k] ------------------ 187| 2.33M| igraph_integer_t next = VECTOR(ptr)[i] - 1; ------------------ | | 69| 2.33M|#define VECTOR(v) ((v).stor_begin) ------------------ 188| 2.33M| VECTOR(*res)[j++] = next; ------------------ | | 69| 2.33M|#define VECTOR(v) ((v).stor_begin) ------------------ 189| 6.25M| while (VECTOR(rad)[next] != 0) { ------------------ | | 69| 6.25M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (189:20): [True: 3.91M, False: 2.33M] ------------------ 190| 3.91M| next = VECTOR(rad)[next] - 1; ------------------ | | 69| 3.91M|#define VECTOR(v) ((v).stor_begin) ------------------ 191| 3.91M| VECTOR(*res)[j++] = next; ------------------ | | 69| 3.91M|#define VECTOR(v) ((v).stor_begin) ------------------ 192| 3.91M| } 193| 2.33M| } 194| 2.79M| } 195| | 196| 188k| igraph_vector_int_destroy(&ptr); 197| 188k| igraph_vector_int_destroy(&rad); 198| 188k| IGRAPH_FINALLY_CLEAN(2); 199| | 200| 188k| return IGRAPH_SUCCESS; 201| 188k|} igraph_vector_int_order1: 205| 709| igraph_integer_t nodes) { 206| 709| igraph_integer_t edges = igraph_vector_int_size(v); 207| 709| igraph_vector_int_t ptr; 208| 709| igraph_vector_int_t rad; 209| 709| igraph_integer_t i, j; 210| | 211| 709| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 709| do { \ | | 1108| 709| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 709] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 709| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 212| 709| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 709| do { \ | | 1108| 709| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 709] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 709| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 213| | 214| 709| IGRAPH_VECTOR_INT_INIT_FINALLY(&ptr, nodes + 1); ------------------ | | 124| 709| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 709| do { \ | | | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 709] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 709| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 709| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 709| do { \ | | | | 696| 709| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 709| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 709| * incorrect destructor function with the pointer */ \ | | | | 699| 709| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 709| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 709| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 215| 709| IGRAPH_VECTOR_INT_INIT_FINALLY(&rad, edges); ------------------ | | 124| 709| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 709| do { \ | | | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 709] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 709| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 709| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 709| do { \ | | | | 696| 709| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 709| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 709| * incorrect destructor function with the pointer */ \ | | | | 699| 709| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 709| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 709| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 216| 709| IGRAPH_CHECK(igraph_vector_int_resize(res, edges)); ------------------ | | 752| 709| do { \ | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 709] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 709| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 217| | 218| 7.90k| for (i = 0; i < edges; i++) { ------------------ | Branch (218:17): [True: 7.19k, False: 709] ------------------ 219| 7.19k| igraph_integer_t radix = v->stor_begin[i]; 220| 7.19k| if (VECTOR(ptr)[radix] != 0) { ------------------ | | 69| 7.19k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (220:13): [True: 5.74k, False: 1.45k] ------------------ 221| 5.74k| VECTOR(rad)[i] = VECTOR(ptr)[radix]; ------------------ | | 69| 5.74k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(rad)[i] = VECTOR(ptr)[radix]; ------------------ | | 69| 5.74k|#define VECTOR(v) ((v).stor_begin) ------------------ 222| 5.74k| } 223| 7.19k| VECTOR(ptr)[radix] = i + 1; ------------------ | | 69| 7.19k|#define VECTOR(v) ((v).stor_begin) ------------------ 224| 7.19k| } 225| | 226| 709| j = 0; 227| 8.61k| for (i = 0; i < nodes + 1; i++) { ------------------ | Branch (227:17): [True: 7.90k, False: 709] ------------------ 228| 7.90k| if (VECTOR(ptr)[i] != 0) { ------------------ | | 69| 7.90k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (228:13): [True: 1.45k, False: 6.45k] ------------------ 229| 1.45k| igraph_integer_t next = VECTOR(ptr)[i] - 1; ------------------ | | 69| 1.45k|#define VECTOR(v) ((v).stor_begin) ------------------ 230| 1.45k| res->stor_begin[j++] = next; 231| 7.19k| while (VECTOR(rad)[next] != 0) { ------------------ | | 69| 7.19k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (231:20): [True: 5.74k, False: 1.45k] ------------------ 232| 5.74k| next = VECTOR(rad)[next] - 1; ------------------ | | 69| 5.74k|#define VECTOR(v) ((v).stor_begin) ------------------ 233| 5.74k| res->stor_begin[j++] = next; 234| 5.74k| } 235| 1.45k| } 236| 7.90k| } 237| | 238| 709| igraph_vector_int_destroy(&ptr); 239| 709| igraph_vector_int_destroy(&rad); 240| 709| IGRAPH_FINALLY_CLEAN(2); 241| | 242| 709| return IGRAPH_SUCCESS; 243| 709|} igraph_vector_int_rank: 278| 43.8k| const igraph_vector_int_t *v, igraph_vector_int_t *res, igraph_integer_t nodes) { 279| | 280| 43.8k| igraph_vector_int_t rad; 281| 43.8k| igraph_vector_int_t ptr; 282| 43.8k| igraph_integer_t edges = igraph_vector_int_size(v); 283| 43.8k| igraph_integer_t i, c = 0; 284| | 285| 43.8k| IGRAPH_VECTOR_INT_INIT_FINALLY(&rad, nodes); ------------------ | | 124| 43.8k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 43.8k| do { \ | | | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 43.8k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 43.8k| do { \ | | | | 696| 43.8k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 43.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 43.8k| * incorrect destructor function with the pointer */ \ | | | | 699| 43.8k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 43.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 286| 43.8k| IGRAPH_VECTOR_INT_INIT_FINALLY(&ptr, edges); ------------------ | | 124| 43.8k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 43.8k| do { \ | | | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 43.8k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 43.8k| do { \ | | | | 696| 43.8k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 43.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 43.8k| * incorrect destructor function with the pointer */ \ | | | | 699| 43.8k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 43.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 287| 43.8k| IGRAPH_CHECK(igraph_vector_int_resize(res, edges)); ------------------ | | 752| 43.8k| do { \ | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 43.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 288| | 289| 6.20M| for (i = 0; i < edges; i++) { ------------------ | Branch (289:17): [True: 6.16M, False: 43.8k] ------------------ 290| 6.16M| igraph_integer_t elem = VECTOR(*v)[i]; ------------------ | | 69| 6.16M|#define VECTOR(v) ((v).stor_begin) ------------------ 291| 6.16M| VECTOR(ptr)[i] = VECTOR(rad)[elem]; ------------------ | | 69| 6.16M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(ptr)[i] = VECTOR(rad)[elem]; ------------------ | | 69| 6.16M|#define VECTOR(v) ((v).stor_begin) ------------------ 292| 6.16M| VECTOR(rad)[elem] = i + 1; ------------------ | | 69| 6.16M|#define VECTOR(v) ((v).stor_begin) ------------------ 293| 6.16M| } 294| | 295| 1.18M| for (i = 0; i < nodes; i++) { ------------------ | Branch (295:17): [True: 1.14M, False: 43.8k] ------------------ 296| 1.14M| igraph_integer_t p = VECTOR(rad)[i]; ------------------ | | 69| 1.14M|#define VECTOR(v) ((v).stor_begin) ------------------ 297| 7.30M| while (p != 0) { ------------------ | Branch (297:16): [True: 6.16M, False: 1.14M] ------------------ 298| 6.16M| VECTOR(*res)[p - 1] = c++; ------------------ | | 69| 6.16M|#define VECTOR(v) ((v).stor_begin) ------------------ 299| 6.16M| p = VECTOR(ptr)[p - 1]; ------------------ | | 69| 6.16M|#define VECTOR(v) ((v).stor_begin) ------------------ 300| 6.16M| } 301| 1.14M| } 302| | 303| 43.8k| igraph_vector_int_destroy(&ptr); 304| 43.8k| igraph_vector_int_destroy(&rad); 305| 43.8k| IGRAPH_FINALLY_CLEAN(2); 306| 43.8k| return IGRAPH_SUCCESS; 307| 43.8k|} igraph_vector_init: 135| 114k|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector)* v, igraph_integer_t size) { 136| 114k| igraph_integer_t alloc_size; 137| 114k| IGRAPH_ASSERT(size >= 0); ------------------ | | 1107| 114k| do { \ | | 1108| 114k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 114k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 114k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 114k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 138| 114k| alloc_size = size > 0 ? size : 1; ------------------ | Branch (138:18): [True: 108k, False: 6.07k] ------------------ 139| | 140| | /* When this function fails, it should leave stor_begin set to NULL, 141| | * so that vector_destroy() is still safe to call on the vector. 142| | * This simplifies freeing partially initialized data structures, 143| | * such as adjacency lists, when an error occurs mid-initialization. */ 144| 114k| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE); ------------------ | | 32| 114k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [True: 114k, False: 0] | | ------------------ ------------------ 145| 114k| if (v->stor_begin == NULL) { ------------------ | Branch (145:9): [True: 0, False: 114k] ------------------ 146| 0| IGRAPH_ERROR("Cannot initialize vector.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 147| 0| } 148| 114k| v->stor_end = v->stor_begin + alloc_size; 149| 114k| v->end = v->stor_begin + size; 150| | 151| 114k| return IGRAPH_SUCCESS; 152| 114k|} igraph_vector_destroy: 400| 114k|void FUNCTION(igraph_vector, destroy) (TYPE(igraph_vector)* v) { 401| 114k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 114k| do { \ | | 1108| 114k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 114k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 114k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 114k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 402| | /* vector_init() will leave stor_begin set to NULL when it fails. 403| | * We handle these cases gracefully. */ 404| 114k| if (v->stor_begin != NULL) { ------------------ | Branch (404:9): [True: 114k, False: 0] ------------------ 405| 114k| IGRAPH_FREE(v->stor_begin); ------------------ | | 35| 114k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 406| 114k| v->stor_begin = NULL; 407| 114k| } 408| 114k|} igraph_vector_capacity: 428| 15.8k|igraph_integer_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector)*v) { 429| 15.8k| return v->stor_end - v->stor_begin; 430| 15.8k|} igraph_vector_reserve: 460| 15.8k|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector)* v, igraph_integer_t capacity) { 461| 15.8k| igraph_integer_t current_capacity; 462| 15.8k| BASE *tmp; ------------------ | | 34| 15.8k| #define BASE igraph_real_t ------------------ 463| | 464| 15.8k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 15.8k| do { \ | | 1108| 15.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 15.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 15.8k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 15.8k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 465| 15.8k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 15.8k| do { \ | | 1108| 15.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 15.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 15.8k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 15.8k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 466| 15.8k| IGRAPH_ASSERT(capacity >= 0); ------------------ | | 1107| 15.8k| do { \ | | 1108| 15.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 15.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 15.8k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 15.8k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 467| | 468| 15.8k| current_capacity = FUNCTION(igraph_vector, capacity)(v); ------------------ | | 161| 15.8k| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 25| 15.8k|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 24| 15.8k|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 469| | 470| 15.8k| if (capacity <= current_capacity) { ------------------ | Branch (470:9): [True: 342, False: 15.4k] ------------------ 471| 342| return IGRAPH_SUCCESS; 472| 342| } 473| | 474| 15.4k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE); ------------------ | | 34| 15.4k|#define IGRAPH_REALLOC(p,n,t) (t*) realloc((void*)(p), (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1) | | ------------------ | | | Branch (34:56): [True: 15.4k, False: 0] | | ------------------ ------------------ 475| 15.4k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector."); ------------------ | | 807| 15.4k| do { \ | | 808| 15.4k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 15.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 15.4k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 15.4k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 476| | 477| 15.4k| v->end = tmp + (v->end - v->stor_begin); 478| 15.4k| v->stor_begin = tmp; 479| 15.4k| v->stor_end = v->stor_begin + capacity; 480| | 481| 15.4k| return IGRAPH_SUCCESS; 482| 15.4k|} igraph_vector_size: 513| 60.6k|igraph_integer_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector)* v) { 514| 60.6k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 60.6k| do { \ | | 1108| 60.6k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 60.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 60.6k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 60.6k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 515| 60.6k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 60.6k| do { \ | | 1108| 60.6k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 60.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 60.6k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 60.6k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 516| 60.6k| return v->end - v->stor_begin; 517| 60.6k|} igraph_vector_push_back: 564| 18.0k|igraph_error_t FUNCTION(igraph_vector, push_back) (TYPE(igraph_vector)* v, BASE e) { 565| 18.0k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 18.0k| do { \ | | 1108| 18.0k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 18.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 18.0k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 18.0k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 566| 18.0k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 18.0k| do { \ | | 1108| 18.0k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 18.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 18.0k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 18.0k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 567| | 568| 18.0k| if (v->stor_end == v->end) { ------------------ | Branch (568:9): [True: 712, False: 17.3k] ------------------ 569| | /* full, allocate more storage */ 570| 712| igraph_integer_t old_size = FUNCTION(igraph_vector, size)(v); ------------------ | | 161| 712| #define FUNCTION(a,c) CONCAT2(a,c) | | ------------------ | | | | 25| 712|#define CONCAT2(a,b) CONCAT2x(a,b) | | | | ------------------ | | | | | | 24| 712|#define CONCAT2x(a,b) a ## _ ## b | | | | ------------------ | | ------------------ ------------------ 571| 712| igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 78| 712|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 78| 712|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (571:37): [True: 712, False: 0] ------------------ 572| 712| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 78| 712|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (572:13): [True: 0, False: 712] ------------------ 573| 0| IGRAPH_ERROR("Cannot push to vector, already at maximum size.", IGRAPH_EOVERFLOW); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 574| 0| } 575| 712| if (new_size == 0) { ------------------ | Branch (575:13): [True: 0, False: 712] ------------------ 576| 0| new_size = 1; 577| 0| } 578| 712| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 752| 712| do { \ | | 753| 712| igraph_error_t igraph_i_ret = (expr); \ | | 754| 712| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 712| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 712] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 712| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 579| 712| } 580| | 581| 18.0k| *(v->end) = e; 582| 18.0k| v->end += 1; 583| | 584| 18.0k| return IGRAPH_SUCCESS; 585| 18.0k|} igraph_vector_fill: 757| 837|void FUNCTION(igraph_vector, fill) (TYPE(igraph_vector)* v, BASE e) { 758| 837| BASE *ptr; ------------------ | | 34| 837| #define BASE igraph_real_t ------------------ 759| 837| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 837| do { \ | | 1108| 837| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 837] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 837| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 760| 837| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 837| do { \ | | 1108| 837| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 837] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 837| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 761| 44.7k| for (ptr = v->stor_begin; ptr < v->end; ptr++) { ------------------ | Branch (761:31): [True: 43.8k, False: 837] ------------------ 762| 43.8k| *ptr = e; 763| 43.8k| } 764| 837|} igraph_vector_resize: 1258| 15.0k|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_integer_t new_size) { 1259| 15.0k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 15.0k| do { \ | | 1108| 15.0k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 15.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 15.0k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 15.0k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1260| 15.0k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 15.0k| do { \ | | 1108| 15.0k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 15.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 15.0k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 15.0k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1261| 15.0k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 752| 15.0k| do { \ | | 753| 15.0k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 15.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 15.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 15.0k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 15.0k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1262| 15.0k| v->end = v->stor_begin + new_size; 1263| 15.0k| return IGRAPH_SUCCESS; 1264| 15.0k|} igraph_vector_min: 1402| 5.36k|BASE FUNCTION(igraph_vector, min)(const TYPE(igraph_vector)* v) { 1403| 5.36k| BASE min; ------------------ | | 34| 5.36k| #define BASE igraph_real_t ------------------ 1404| 5.36k| BASE *ptr; ------------------ | | 34| 5.36k| #define BASE igraph_real_t ------------------ 1405| 5.36k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 5.36k| do { \ | | 1108| 5.36k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 5.36k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1406| 5.36k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 5.36k| do { \ | | 1108| 5.36k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 5.36k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1407| 5.36k| IGRAPH_ASSERT(v->stor_begin != v->end); ------------------ | | 1107| 5.36k| do { \ | | 1108| 5.36k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 5.36k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1408| 5.36k| min = *(v->stor_begin); 1409| 5.36k|#if defined(BASE_IGRAPH_REAL) 1410| 5.36k| if (isnan(min)) { return min; }; /* Result is NaN */ 1411| 5.36k|#endif 1412| 5.36k| ptr = v->stor_begin + 1; 1413| 309k| while (ptr < v->end) { ------------------ | Branch (1413:12): [True: 304k, False: 5.36k] ------------------ 1414| 304k| if ((*ptr) < min) { ------------------ | Branch (1414:13): [True: 0, False: 304k] ------------------ 1415| 0| min = *ptr; 1416| 0| } 1417| 304k|#if defined(BASE_IGRAPH_REAL) 1418| 304k| else if (isnan(*ptr)) { 1419| 0| return *ptr; /* Result is NaN */ 1420| 0| } 1421| 304k|#endif 1422| 304k| ptr++; 1423| 304k| } 1424| 5.36k| return min; 1425| 5.36k|} igraph_vector_bool_init: 135| 26.6k|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector)* v, igraph_integer_t size) { 136| 26.6k| igraph_integer_t alloc_size; 137| 26.6k| IGRAPH_ASSERT(size >= 0); ------------------ | | 1107| 26.6k| do { \ | | 1108| 26.6k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 26.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 26.6k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 26.6k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 138| 26.6k| alloc_size = size > 0 ? size : 1; ------------------ | Branch (138:18): [True: 25.5k, False: 1.15k] ------------------ 139| | 140| | /* When this function fails, it should leave stor_begin set to NULL, 141| | * so that vector_destroy() is still safe to call on the vector. 142| | * This simplifies freeing partially initialized data structures, 143| | * such as adjacency lists, when an error occurs mid-initialization. */ 144| 26.6k| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE); ------------------ | | 32| 26.6k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [True: 26.6k, False: 0] | | ------------------ ------------------ 145| 26.6k| if (v->stor_begin == NULL) { ------------------ | Branch (145:9): [True: 0, False: 26.6k] ------------------ 146| 0| IGRAPH_ERROR("Cannot initialize vector.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 147| 0| } 148| 26.6k| v->stor_end = v->stor_begin + alloc_size; 149| 26.6k| v->end = v->stor_begin + size; 150| | 151| 26.6k| return IGRAPH_SUCCESS; 152| 26.6k|} igraph_vector_bool_destroy: 400| 26.6k|void FUNCTION(igraph_vector, destroy) (TYPE(igraph_vector)* v) { 401| 26.6k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 26.6k| do { \ | | 1108| 26.6k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 26.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 26.6k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 26.6k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 402| | /* vector_init() will leave stor_begin set to NULL when it fails. 403| | * We handle these cases gracefully. */ 404| 26.6k| if (v->stor_begin != NULL) { ------------------ | Branch (404:9): [True: 26.6k, False: 0] ------------------ 405| 26.6k| IGRAPH_FREE(v->stor_begin); ------------------ | | 35| 26.6k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 406| 26.6k| v->stor_begin = NULL; 407| 26.6k| } 408| 26.6k|} igraph_vector_bool_fill: 757| 13.8k|void FUNCTION(igraph_vector, fill) (TYPE(igraph_vector)* v, BASE e) { 758| 13.8k| BASE *ptr; ------------------ | | 58| 13.8k| #define BASE igraph_bool_t ------------------ 759| 13.8k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 13.8k| do { \ | | 1108| 13.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 13.8k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 760| 13.8k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 13.8k| do { \ | | 1108| 13.8k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 13.8k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 761| 111k| for (ptr = v->stor_begin; ptr < v->end; ptr++) { ------------------ | Branch (761:31): [True: 97.5k, False: 13.8k] ------------------ 762| 97.5k| *ptr = e; 763| 97.5k| } 764| 13.8k|} igraph_vector_int_init: 135| 2.59M|igraph_error_t FUNCTION(igraph_vector, init)(TYPE(igraph_vector)* v, igraph_integer_t size) { 136| 2.59M| igraph_integer_t alloc_size; 137| 2.59M| IGRAPH_ASSERT(size >= 0); ------------------ | | 1107| 2.59M| do { \ | | 1108| 2.59M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 2.59M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.59M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 2.59M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 138| 2.59M| alloc_size = size > 0 ? size : 1; ------------------ | Branch (138:18): [True: 1.96M, False: 631k] ------------------ 139| | 140| | /* When this function fails, it should leave stor_begin set to NULL, 141| | * so that vector_destroy() is still safe to call on the vector. 142| | * This simplifies freeing partially initialized data structures, 143| | * such as adjacency lists, when an error occurs mid-initialization. */ 144| 2.59M| v->stor_begin = IGRAPH_CALLOC(alloc_size, BASE); ------------------ | | 32| 2.59M|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [True: 2.59M, False: 0] | | ------------------ ------------------ 145| 2.59M| if (v->stor_begin == NULL) { ------------------ | Branch (145:9): [True: 0, False: 2.59M] ------------------ 146| 0| IGRAPH_ERROR("Cannot initialize vector.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 147| 0| } 148| 2.59M| v->stor_end = v->stor_begin + alloc_size; 149| 2.59M| v->end = v->stor_begin + size; 150| | 151| 2.59M| return IGRAPH_SUCCESS; 152| 2.59M|} igraph_vector_int_destroy: 400| 2.59M|void FUNCTION(igraph_vector, destroy) (TYPE(igraph_vector)* v) { 401| 2.59M| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 2.59M| do { \ | | 1108| 2.59M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 2.59M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.59M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 2.59M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 402| | /* vector_init() will leave stor_begin set to NULL when it fails. 403| | * We handle these cases gracefully. */ 404| 2.59M| if (v->stor_begin != NULL) { ------------------ | Branch (404:9): [True: 2.59M, False: 0] ------------------ 405| 2.59M| IGRAPH_FREE(v->stor_begin); ------------------ | | 35| 2.59M|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 406| 2.59M| v->stor_begin = NULL; 407| 2.59M| } 408| 2.59M|} igraph_vector_int_capacity: 428| 2.73M|igraph_integer_t FUNCTION(igraph_vector, capacity)(const TYPE(igraph_vector)*v) { 429| 2.73M| return v->stor_end - v->stor_begin; 430| 2.73M|} igraph_vector_int_reserve: 460| 2.73M|igraph_error_t FUNCTION(igraph_vector, reserve)(TYPE(igraph_vector)* v, igraph_integer_t capacity) { 461| 2.73M| igraph_integer_t current_capacity; 462| 2.73M| BASE *tmp; ------------------ | | 71| 2.73M| #define BASE igraph_integer_t ------------------ 463| | 464| 2.73M| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 2.73M| do { \ | | 1108| 2.73M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 2.73M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.73M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 2.73M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 465| 2.73M| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 2.73M| do { \ | | 1108| 2.73M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 2.73M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.73M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 2.73M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 466| 2.73M| IGRAPH_ASSERT(capacity >= 0); ------------------ | | 1107| 2.73M| do { \ | | 1108| 2.73M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 2.73M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.73M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 2.73M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 467| | 468| 2.73M| current_capacity = FUNCTION(igraph_vector, capacity)(v); ------------------ | | 169| 2.73M| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 27| 2.73M|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 2.73M|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 469| | 470| 2.73M| if (capacity <= current_capacity) { ------------------ | Branch (470:9): [True: 1.94M, False: 788k] ------------------ 471| 1.94M| return IGRAPH_SUCCESS; 472| 1.94M| } 473| | 474| 788k| tmp = IGRAPH_REALLOC(v->stor_begin, capacity, BASE); ------------------ | | 34| 788k|#define IGRAPH_REALLOC(p,n,t) (t*) realloc((void*)(p), (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1) | | ------------------ | | | Branch (34:56): [True: 788k, False: 0] | | ------------------ ------------------ 475| 788k| IGRAPH_CHECK_OOM(tmp, "Cannot reserve space for vector."); ------------------ | | 807| 788k| do { \ | | 808| 788k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 788k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 788k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 788k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 476| | 477| 788k| v->end = tmp + (v->end - v->stor_begin); 478| 788k| v->stor_begin = tmp; 479| 788k| v->stor_end = v->stor_begin + capacity; 480| | 481| 788k| return IGRAPH_SUCCESS; 482| 788k|} igraph_vector_int_empty: 496| 470k|igraph_bool_t FUNCTION(igraph_vector, empty)(const TYPE(igraph_vector)* v) { 497| 470k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 470k| do { \ | | 1108| 470k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 470k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 470k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 470k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 498| 470k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 470k| do { \ | | 1108| 470k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 470k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 470k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 470k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 499| 470k| return v->stor_begin == v->end; 500| 470k|} igraph_vector_int_size: 513| 23.5M|igraph_integer_t FUNCTION(igraph_vector, size)(const TYPE(igraph_vector)* v) { 514| 23.5M| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 23.5M| do { \ | | 1108| 23.5M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 23.5M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 23.5M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 23.5M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 515| 23.5M| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 23.5M| do { \ | | 1108| 23.5M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 23.5M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 23.5M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 23.5M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 516| 23.5M| return v->end - v->stor_begin; 517| 23.5M|} igraph_vector_int_clear: 533| 526k|void FUNCTION(igraph_vector, clear)(TYPE(igraph_vector)* v) { 534| 526k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 526k| do { \ | | 1108| 526k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 526k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 526k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 526k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 535| 526k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 526k| do { \ | | 1108| 526k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 526k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 526k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 526k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 536| 526k| v->end = v->stor_begin; 537| 526k|} igraph_vector_int_push_back: 564| 7.15M|igraph_error_t FUNCTION(igraph_vector, push_back) (TYPE(igraph_vector)* v, BASE e) { 565| 7.15M| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 7.15M| do { \ | | 1108| 7.15M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 7.15M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 7.15M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 7.15M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 566| 7.15M| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 7.15M| do { \ | | 1108| 7.15M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 7.15M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 7.15M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 7.15M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 567| | 568| 7.15M| if (v->stor_end == v->end) { ------------------ | Branch (568:9): [True: 265k, False: 6.89M] ------------------ 569| | /* full, allocate more storage */ 570| 265k| igraph_integer_t old_size = FUNCTION(igraph_vector, size)(v); ------------------ | | 169| 265k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 27| 265k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 265k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 571| 265k| igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 78| 265k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ igraph_integer_t new_size = old_size < IGRAPH_INTEGER_MAX/2 ? old_size * 2 : IGRAPH_INTEGER_MAX; ------------------ | | 78| 265k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (571:37): [True: 265k, False: 0] ------------------ 572| 265k| if (old_size == IGRAPH_INTEGER_MAX) { ------------------ | | 78| 265k|# define IGRAPH_INTEGER_MAX INT64_MAX ------------------ | Branch (572:13): [True: 0, False: 265k] ------------------ 573| 0| IGRAPH_ERROR("Cannot push to vector, already at maximum size.", IGRAPH_EOVERFLOW); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 574| 0| } 575| 265k| if (new_size == 0) { ------------------ | Branch (575:13): [True: 0, False: 265k] ------------------ 576| 0| new_size = 1; 577| 0| } 578| 265k| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 752| 265k| do { \ | | 753| 265k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 265k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 265k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 265k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 265k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 579| 265k| } 580| | 581| 7.15M| *(v->end) = e; 582| 7.15M| v->end += 1; 583| | 584| 7.15M| return IGRAPH_SUCCESS; 585| 7.15M|} igraph_vector_int_null: 737| 803k|void FUNCTION(igraph_vector, null) (TYPE(igraph_vector)* v) { 738| 803k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 803k| do { \ | | 1108| 803k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 803k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 803k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 803k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 739| 803k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 803k| do { \ | | 1108| 803k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 803k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 803k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 803k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 740| 803k| if (FUNCTION(igraph_vector, size)(v) > 0) { ------------------ | | 169| 803k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 27| 803k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 803k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ | Branch (740:9): [True: 798k, False: 5.36k] ------------------ 741| 798k| memset(v->stor_begin, 0, sizeof(BASE) * FUNCTION(igraph_vector, size)(v)); ------------------ | | 169| 798k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 27| 798k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 798k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 742| 798k| } 743| 803k|} igraph_vector_int_fill: 757| 59.6k|void FUNCTION(igraph_vector, fill) (TYPE(igraph_vector)* v, BASE e) { 758| 59.6k| BASE *ptr; ------------------ | | 71| 59.6k| #define BASE igraph_integer_t ------------------ 759| 59.6k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 59.6k| do { \ | | 1108| 59.6k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 59.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 59.6k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 59.6k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 760| 59.6k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 59.6k| do { \ | | 1108| 59.6k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 59.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 59.6k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 59.6k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 761| 1.35M| for (ptr = v->stor_begin; ptr < v->end; ptr++) { ------------------ | Branch (761:31): [True: 1.29M, False: 59.6k] ------------------ 762| 1.29M| *ptr = e; 763| 1.29M| } 764| 59.6k|} igraph_vector_int_tail: 814| 439k|BASE FUNCTION(igraph_vector, tail)(const TYPE(igraph_vector) *v) { 815| 439k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 439k| do { \ | | 1108| 439k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 439k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 439k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 439k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 816| 439k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 439k| do { \ | | 1108| 439k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 439k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 439k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 439k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 817| 439k| return *((v->end) - 1); 818| 439k|} igraph_vector_int_pop_back: 833| 200k|BASE FUNCTION(igraph_vector, pop_back)(TYPE(igraph_vector)* v) { 834| 200k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 200k| do { \ | | 1108| 200k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 200k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 200k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 200k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 835| 200k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 200k| do { \ | | 1108| 200k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 200k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 200k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 200k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 836| 200k| IGRAPH_ASSERT(v->end != NULL); ------------------ | | 1107| 200k| do { \ | | 1108| 200k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 200k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 200k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 200k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 837| 200k| IGRAPH_ASSERT(v->end != v->stor_begin); ------------------ | | 1107| 200k| do { \ | | 1108| 200k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 200k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 200k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 200k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 838| | 839| 200k| (v->end)--; 840| | 841| 200k| return *(v->end); 842| 200k|} igraph_vector_int_sort: 953| 303k|void FUNCTION(igraph_vector, sort)(TYPE(igraph_vector) *v) { 954| 303k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 303k| do { \ | | 1108| 303k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 303k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 303k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 303k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 955| 303k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 303k| do { \ | | 1108| 303k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 303k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 303k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 303k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 956| 303k| igraph_qsort(v->stor_begin, FUNCTION(igraph_vector, size)(v), ------------------ | | 169| 303k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 27| 303k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 303k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 957| 303k| sizeof(BASE), FUNCTION(igraph_vector, sort_cmp)); ------------------ | | 169| 303k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 27| 303k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 303k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 958| 303k|} igraph_vector_int_resize: 1258| 2.18M|igraph_error_t FUNCTION(igraph_vector, resize)(TYPE(igraph_vector)* v, igraph_integer_t new_size) { 1259| 2.18M| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 2.18M| do { \ | | 1108| 2.18M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 2.18M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.18M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 2.18M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1260| 2.18M| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 2.18M| do { \ | | 1108| 2.18M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 2.18M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.18M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 2.18M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1261| 2.18M| IGRAPH_CHECK(FUNCTION(igraph_vector, reserve)(v, new_size)); ------------------ | | 752| 2.18M| do { \ | | 753| 2.18M| igraph_error_t igraph_i_ret = (expr); \ | | 754| 2.18M| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 2.18M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 2.18M] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 2.18M| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1262| 2.18M| v->end = v->stor_begin + new_size; 1263| 2.18M| return IGRAPH_SUCCESS; 1264| 2.18M|} igraph_vector_int_max: 1322| 47.2k|BASE FUNCTION(igraph_vector, max)(const TYPE(igraph_vector)* v) { 1323| 47.2k| BASE max; ------------------ | | 71| 47.2k| #define BASE igraph_integer_t ------------------ 1324| 47.2k| BASE *ptr; ------------------ | | 71| 47.2k| #define BASE igraph_integer_t ------------------ 1325| 47.2k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 47.2k| do { \ | | 1108| 47.2k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 47.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 47.2k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 47.2k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1326| 47.2k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 47.2k| do { \ | | 1108| 47.2k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 47.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 47.2k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 47.2k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1327| 47.2k| IGRAPH_ASSERT(v->stor_begin != v->end); ------------------ | | 1107| 47.2k| do { \ | | 1108| 47.2k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 47.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 47.2k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 47.2k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1328| 47.2k| max = *(v->stor_begin); 1329| |#if defined(BASE_IGRAPH_REAL) 1330| | if (isnan(max)) { return max; }; /* Result is NaN */ 1331| |#endif 1332| 47.2k| ptr = v->stor_begin + 1; 1333| 2.64M| while (ptr < v->end) { ------------------ | Branch (1333:12): [True: 2.59M, False: 47.2k] ------------------ 1334| 2.59M| if ((*ptr) > max) { ------------------ | Branch (1334:13): [True: 256k, False: 2.34M] ------------------ 1335| 256k| max = *ptr; 1336| 256k| } 1337| |#if defined(BASE_IGRAPH_REAL) 1338| | else if (isnan(*ptr)) 1339| | return *ptr; /* Result is NaN */ 1340| |#endif 1341| 2.59M| ptr++; 1342| 2.59M| } 1343| 47.2k| return max; 1344| 47.2k|} igraph_vector_int_min: 1402| 929|BASE FUNCTION(igraph_vector, min)(const TYPE(igraph_vector)* v) { 1403| 929| BASE min; ------------------ | | 71| 929| #define BASE igraph_integer_t ------------------ 1404| 929| BASE *ptr; ------------------ | | 71| 929| #define BASE igraph_integer_t ------------------ 1405| 929| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 929| do { \ | | 1108| 929| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 929| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 929] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 929| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1406| 929| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 929| do { \ | | 1108| 929| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 929| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 929] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 929| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1407| 929| IGRAPH_ASSERT(v->stor_begin != v->end); ------------------ | | 1107| 929| do { \ | | 1108| 929| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 929| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 929] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 929| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1408| 929| min = *(v->stor_begin); 1409| |#if defined(BASE_IGRAPH_REAL) 1410| | if (isnan(min)) { return min; }; /* Result is NaN */ 1411| |#endif 1412| 929| ptr = v->stor_begin + 1; 1413| 8.49k| while (ptr < v->end) { ------------------ | Branch (1413:12): [True: 7.56k, False: 929] ------------------ 1414| 7.56k| if ((*ptr) < min) { ------------------ | Branch (1414:13): [True: 527, False: 7.04k] ------------------ 1415| 527| min = *ptr; 1416| 527| } 1417| |#if defined(BASE_IGRAPH_REAL) 1418| | else if (isnan(*ptr)) { 1419| | return *ptr; /* Result is NaN */ 1420| | } 1421| |#endif 1422| 7.56k| ptr++; 1423| 7.56k| } 1424| 929| return min; 1425| 929|} igraph_vector_int_init_copy: 1546| 216k|) { 1547| 216k| igraph_integer_t from_size; 1548| | 1549| 216k| IGRAPH_ASSERT(from != NULL); ------------------ | | 1107| 216k| do { \ | | 1108| 216k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 216k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 216k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 216k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1550| 216k| IGRAPH_ASSERT(from->stor_begin != NULL); ------------------ | | 1107| 216k| do { \ | | 1108| 216k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 216k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 216k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 216k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1551| | 1552| 216k| from_size = FUNCTION(igraph_vector, size)(from); ------------------ | | 169| 216k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 27| 216k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 216k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 1553| 216k| IGRAPH_CHECK(FUNCTION(igraph_vector, init)(to, from_size)); ------------------ | | 752| 216k| do { \ | | 753| 216k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 216k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 216k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 216k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 216k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1554| | 1555| 216k| memcpy(to->stor_begin, from->stor_begin, from_size * sizeof(BASE)); 1556| | 1557| 216k| return IGRAPH_SUCCESS; 1558| 216k|} igraph_vector_int_isininterval: 1893| 183k| BASE high) { 1894| 183k| BASE *ptr; ------------------ | | 71| 183k| #define BASE igraph_integer_t ------------------ 1895| 183k| IGRAPH_ASSERT(v != NULL); ------------------ | | 1107| 183k| do { \ | | 1108| 183k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 183k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 183k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 183k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1896| 183k| IGRAPH_ASSERT(v->stor_begin != NULL); ------------------ | | 1107| 183k| do { \ | | 1108| 183k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 183k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 183k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 183k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1897| 5.51M| for (ptr = v->stor_begin; ptr < v->end; ptr++) { ------------------ | Branch (1897:31): [True: 5.33M, False: 183k] ------------------ 1898| | /* Note that the following is not equivalent to *ptr < low || *ptr > high 1899| | * when *ptr is NaN! */ 1900| 5.33M| if (!(*ptr >= low && *ptr <= high)) { ------------------ | Branch (1900:15): [True: 5.33M, False: 0] | Branch (1900:30): [True: 5.33M, False: 0] ------------------ 1901| 0| return 0; 1902| 0| } 1903| 5.33M| } 1904| 183k| return 1; 1905| 183k|} igraph_vector_int_all_e: 1955| 6.76M| const TYPE(igraph_vector) *rhs) { 1956| 6.76M| igraph_integer_t i, s; 1957| 6.76M| IGRAPH_ASSERT(lhs != 0); ------------------ | | 1107| 6.76M| do { \ | | 1108| 6.76M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 6.76M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 6.76M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 6.76M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1958| 6.76M| IGRAPH_ASSERT(rhs != 0); ------------------ | | 1107| 6.76M| do { \ | | 1108| 6.76M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 6.76M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 6.76M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 6.76M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1959| 6.76M| IGRAPH_ASSERT(lhs->stor_begin != 0); ------------------ | | 1107| 6.76M| do { \ | | 1108| 6.76M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 6.76M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 6.76M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 6.76M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1960| 6.76M| IGRAPH_ASSERT(rhs->stor_begin != 0); ------------------ | | 1107| 6.76M| do { \ | | 1108| 6.76M| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 6.76M| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 6.76M] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 6.76M| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1961| | 1962| 6.76M| s = FUNCTION(igraph_vector, size)(lhs); ------------------ | | 169| 6.76M| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 27| 6.76M|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 6.76M|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 1963| 6.76M| if (s != FUNCTION(igraph_vector, size)(rhs)) { ------------------ | | 169| 6.76M| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 27| 6.76M|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 6.76M|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ | Branch (1963:9): [True: 3.05M, False: 3.71M] ------------------ 1964| 3.05M| return false; 1965| 3.71M| } else { 1966| 5.58M| for (i = 0; i < s; i++) { ------------------ | Branch (1966:21): [True: 5.31M, False: 267k] ------------------ 1967| 5.31M| BASE l = VECTOR(*lhs)[i]; ------------------ | | 71| 5.31M| #define BASE igraph_integer_t ------------------ BASE l = VECTOR(*lhs)[i]; ------------------ | | 69| 5.31M|#define VECTOR(v) ((v).stor_begin) ------------------ 1968| 5.31M| BASE r = VECTOR(*rhs)[i]; ------------------ | | 71| 5.31M| #define BASE igraph_integer_t ------------------ BASE r = VECTOR(*rhs)[i]; ------------------ | | 69| 5.31M|#define VECTOR(v) ((v).stor_begin) ------------------ 1969| |#ifdef EQ 1970| | if (!EQ(l, r)) { 1971| |#else 1972| 5.31M| if (l != r) { ------------------ | Branch (1972:17): [True: 3.44M, False: 1.87M] ------------------ 1973| 3.44M|#endif 1974| 3.44M| return false; 1975| 3.44M| } 1976| 5.31M| } 1977| 267k| return true; 1978| 3.71M| } 1979| 6.76M|} igraph_vector_int_append: 2462| 21.7k| const TYPE(igraph_vector) *from) { 2463| 21.7k| igraph_integer_t tosize, fromsize; 2464| 21.7k| igraph_integer_t newsize; 2465| | 2466| 21.7k| tosize = FUNCTION(igraph_vector, size)(to); ------------------ | | 169| 21.7k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 27| 21.7k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 21.7k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 2467| 21.7k| fromsize = FUNCTION(igraph_vector, size)(from); ------------------ | | 169| 21.7k| #define FUNCTION(a,c) CONCAT3(a,SHORT,c) | | ------------------ | | | | 27| 21.7k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 21.7k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 2468| 21.7k| IGRAPH_SAFE_ADD(tosize, fromsize, &newsize); ------------------ | | 47| 21.7k| do { \ | | 48| 21.7k| igraph_integer_t _safe_a = (a), _safe_b = (b); \ | | 49| 21.7k| igraph_integer_t _safe_sum; \ | | 50| 21.7k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 21.7k] | | ------------------ | | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \ | | ------------------ | | | | 550| 0| do { \ | | | | 551| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | | | 552| 0| igraph_errno, __VA_ARGS__) ; \ | | | | 553| 0| return igraph_errno; \ | | | | 554| 0| } while (0) | | | | ------------------ | | | | | Branch (554:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 52| 0| } \ | | 53| 21.7k| *(res) = _safe_sum; \ | | 54| 21.7k| } while (0) | | ------------------ | | | Branch (54:14): [Folded - Ignored] | | ------------------ ------------------ 2469| 21.7k| IGRAPH_CHECK(FUNCTION(igraph_vector, resize)(to, newsize)); ------------------ | | 752| 21.7k| do { \ | | 753| 21.7k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 21.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 21.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 21.7k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 21.7k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2470| 21.7k| memcpy(to->stor_begin + tosize, from->stor_begin, 2471| 21.7k| sizeof(BASE) * fromsize); 2472| 21.7k| to->end = to->stor_begin + tosize + fromsize; 2473| | 2474| 21.7k| return IGRAPH_SUCCESS; 2475| 21.7k|} igraph_vector_int_swap: 2566| 13.7k|igraph_error_t FUNCTION(igraph_vector, swap)(TYPE(igraph_vector) *v1, TYPE(igraph_vector) *v2) { 2567| | 2568| 13.7k| TYPE(igraph_vector) tmp; ------------------ | | 170| 13.7k| #define TYPE(a) CONCAT3(a,SHORT,t) | | ------------------ | | | | 27| 13.7k|#define CONCAT3(a,b,c) CONCAT3x(a,b,c) | | | | ------------------ | | | | | | 26| 13.7k|#define CONCAT3x(a,b,c) a ## _ ## b ## _ ## c | | | | ------------------ | | ------------------ ------------------ 2569| | 2570| 13.7k| tmp = *v1; 2571| 13.7k| *v1 = *v2; 2572| 13.7k| *v2 = tmp; 2573| | 2574| 13.7k| return IGRAPH_SUCCESS; 2575| 13.7k|} vector.c:igraph_vector_int_sort_cmp: 919| 1.39M|static int FUNCTION(igraph_vector, sort_cmp)(const void *a, const void *b) { 920| 1.39M| const BASE *da = (const BASE *) a; 921| 1.39M| const BASE *db = (const BASE *) b; 922| | 923| 1.39M| return (*da > *db) - (*da < *db); 924| 1.39M|} igraph_maxflow: 492| 43.8k| igraph_maxflow_stats_t *stats) { 493| | 494| 43.8k| igraph_integer_t no_of_nodes = igraph_vcount(graph); 495| 43.8k| igraph_integer_t no_of_orig_edges = igraph_ecount(graph); 496| 43.8k| igraph_integer_t no_of_edges = 2 * no_of_orig_edges; 497| | 498| 43.8k| igraph_vector_t rescap, excess; 499| 43.8k| igraph_vector_int_t from, to, rev, distance; 500| 43.8k| igraph_vector_int_t edges, rank; 501| 43.8k| igraph_vector_int_t current, first; 502| 43.8k| igraph_buckets_t buckets; 503| 43.8k| igraph_dbuckets_t ibuckets; 504| | 505| 43.8k| igraph_dqueue_int_t bfsq; 506| | 507| 43.8k| igraph_integer_t i, j, idx; 508| 43.8k| igraph_integer_t npushsince = 0, nrelabelsince = 0; 509| | 510| 43.8k| igraph_maxflow_stats_t local_stats; /* used if the user passed a null pointer for stats */ 511| | 512| 43.8k| if (stats == 0) { ------------------ | Branch (512:9): [True: 29.4k, False: 14.3k] ------------------ 513| 29.4k| stats = &local_stats; 514| 29.4k| } 515| | 516| 43.8k| if (!igraph_is_directed(graph)) { ------------------ | Branch (516:9): [True: 0, False: 43.8k] ------------------ 517| 0| IGRAPH_CHECK(igraph_i_maxflow_undirected(graph, value, flow, cut, ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 518| 0| partition, partition2, source, 519| 0| target, capacity, stats)); 520| 0| return IGRAPH_SUCCESS; 521| 0| } 522| | 523| 43.8k| if (capacity && igraph_vector_size(capacity) != no_of_orig_edges) { ------------------ | Branch (523:9): [True: 43.8k, False: 0] | Branch (523:21): [True: 0, False: 43.8k] ------------------ 524| 0| IGRAPH_ERROR("Capacity vector must match number of edges in length.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 525| 0| } 526| 43.8k| if (source < 0 || source >= no_of_nodes || target < 0 || target >= no_of_nodes) { ------------------ | Branch (526:9): [True: 0, False: 43.8k] | Branch (526:23): [True: 0, False: 43.8k] | Branch (526:48): [True: 0, False: 43.8k] | Branch (526:62): [True: 0, False: 43.8k] ------------------ 527| 0| IGRAPH_ERROR("Invalid source or target vertex.", IGRAPH_EINVVID); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 528| 0| } 529| | 530| 43.8k| stats->nopush = stats->norelabel = stats->nogap = stats->nogapnodes = 531| 43.8k| stats->nobfs = 0; 532| | 533| | /* 534| | * The data structure: 535| | * - First of all, we consider every edge twice, first the edge 536| | * itself, but also its opposite. 537| | * - (from, to) contain all edges (original + opposite), ordered by 538| | * the id of the source vertex. During the algorithm we just need 539| | * 'to', so from is destroyed soon. We only need it in the 540| | * beginning, to create the 'first' pointers. 541| | * - 'first' is a pointer vector for 'to', first[i] points to the 542| | * first neighbor of vertex i and first[i+1]-1 is the last 543| | * neighbor of vertex i. (Unless vertex i is isolate, in which 544| | * case first[i]==first[i+1]). 545| | * - 'rev' contains a mapping from an edge to its opposite pair 546| | * - 'rescap' contains the residual capacities of the edges, this is 547| | * initially equal to the capacity of the edges for the original 548| | * edges and it is zero for the opposite edges. 549| | * - 'excess' contains the excess flow for the vertices. I.e. the flow 550| | * that is coming in, but it is not going out. 551| | * - 'current' stores the next neighboring vertex to check, for every 552| | * vertex, when excess flow is being pushed to neighbors. 553| | * - 'distance' stores the distance of the vertices from the source. 554| | * - 'rank' and 'edges' are only needed temporarily, for ordering and 555| | * storing the edges. 556| | * - we use an igraph_buckets_t data structure ('buckets') to find 557| | * the vertices with the highest 'distance' values quickly. 558| | * This always contains the vertices that have a positive excess 559| | * flow. 560| | */ 561| 43.8k|#undef FIRST 562| 43.8k|#undef LAST 563| 43.8k|#undef CURRENT 564| 43.8k|#undef RESCAP 565| 43.8k|#undef REV 566| 43.8k|#undef HEAD 567| 43.8k|#undef EXCESS 568| 43.8k|#undef DIST 569| 43.8k|#define FIRST(i) (VECTOR(first)[(i)]) 570| 43.8k|#define LAST(i) (VECTOR(first)[(i)+1]) 571| 43.8k|#define CURRENT(i) (VECTOR(current)[(i)]) 572| 43.8k|#define RESCAP(i) (VECTOR(rescap)[(i)]) 573| 43.8k|#define REV(i) (VECTOR(rev)[(i)]) 574| 43.8k|#define HEAD(i) (VECTOR(to)[(i)]) 575| 43.8k|#define EXCESS(i) (VECTOR(excess)[(i)]) 576| 43.8k|#define DIST(i) (VECTOR(distance)[(i)]) 577| | 578| 43.8k| IGRAPH_CHECK(igraph_dqueue_int_init(&bfsq, no_of_nodes)); ------------------ | | 752| 43.8k| do { \ | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 43.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 579| 43.8k| IGRAPH_FINALLY(igraph_dqueue_int_destroy, &bfsq); ------------------ | | 695| 43.8k| do { \ | | 696| 43.8k| /* the following branch makes the compiler check the compatibility of \ | | 697| 43.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 43.8k| * incorrect destructor function with the pointer */ \ | | 699| 43.8k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 43.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 43.8k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 580| 43.8k| IGRAPH_VECTOR_INT_INIT_FINALLY(&to, no_of_edges); ------------------ | | 124| 43.8k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 43.8k| do { \ | | | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 43.8k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 43.8k| do { \ | | | | 696| 43.8k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 43.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 43.8k| * incorrect destructor function with the pointer */ \ | | | | 699| 43.8k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 43.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 581| 43.8k| IGRAPH_VECTOR_INT_INIT_FINALLY(&rev, no_of_edges); ------------------ | | 124| 43.8k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 43.8k| do { \ | | | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 43.8k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 43.8k| do { \ | | | | 696| 43.8k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 43.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 43.8k| * incorrect destructor function with the pointer */ \ | | | | 699| 43.8k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 43.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 582| 43.8k| IGRAPH_VECTOR_INIT_FINALLY(&rescap, no_of_edges); ------------------ | | 109| 43.8k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \ | | ------------------ | | | | 752| 43.8k| do { \ | | | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 110| 43.8k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0) | | ------------------ | | | | 695| 43.8k| do { \ | | | | 696| 43.8k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 43.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 43.8k| * incorrect destructor function with the pointer */ \ | | | | 699| 43.8k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 43.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (110:60): [Folded - Ignored] | | ------------------ ------------------ 583| 43.8k| IGRAPH_VECTOR_INIT_FINALLY(&excess, no_of_nodes); ------------------ | | 109| 43.8k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \ | | ------------------ | | | | 752| 43.8k| do { \ | | | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 110| 43.8k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0) | | ------------------ | | | | 695| 43.8k| do { \ | | | | 696| 43.8k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 43.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 43.8k| * incorrect destructor function with the pointer */ \ | | | | 699| 43.8k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 43.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (110:60): [Folded - Ignored] | | ------------------ ------------------ 584| 43.8k| IGRAPH_VECTOR_INT_INIT_FINALLY(&distance, no_of_nodes); ------------------ | | 124| 43.8k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 43.8k| do { \ | | | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 43.8k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 43.8k| do { \ | | | | 696| 43.8k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 43.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 43.8k| * incorrect destructor function with the pointer */ \ | | | | 699| 43.8k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 43.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 585| 43.8k| IGRAPH_VECTOR_INT_INIT_FINALLY(&first, no_of_nodes + 1); ------------------ | | 124| 43.8k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 43.8k| do { \ | | | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 43.8k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 43.8k| do { \ | | | | 696| 43.8k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 43.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 43.8k| * incorrect destructor function with the pointer */ \ | | | | 699| 43.8k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 43.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 586| | 587| 43.8k| IGRAPH_VECTOR_INT_INIT_FINALLY(&rank, no_of_edges); ------------------ | | 124| 43.8k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 43.8k| do { \ | | | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 43.8k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 43.8k| do { \ | | | | 696| 43.8k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 43.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 43.8k| * incorrect destructor function with the pointer */ \ | | | | 699| 43.8k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 43.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 588| 43.8k| IGRAPH_VECTOR_INT_INIT_FINALLY(&from, no_of_edges); ------------------ | | 124| 43.8k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 43.8k| do { \ | | | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 43.8k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 43.8k| do { \ | | | | 696| 43.8k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 43.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 43.8k| * incorrect destructor function with the pointer */ \ | | | | 699| 43.8k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 43.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 589| 43.8k| IGRAPH_VECTOR_INT_INIT_FINALLY(&edges, no_of_edges); ------------------ | | 124| 43.8k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 43.8k| do { \ | | | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 43.8k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 43.8k| do { \ | | | | 696| 43.8k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 43.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 43.8k| * incorrect destructor function with the pointer */ \ | | | | 699| 43.8k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 43.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 590| | 591| | /* Create the basic data structure */ 592| 43.8k| IGRAPH_CHECK(igraph_get_edgelist(graph, &edges, 0)); ------------------ | | 752| 43.8k| do { \ | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 43.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 593| 43.8k| IGRAPH_CHECK(igraph_vector_int_rank(&edges, &rank, no_of_nodes)); ------------------ | | 752| 43.8k| do { \ | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 43.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 594| | 595| 3.12M| for (i = 0; i < no_of_edges; i += 2) { ------------------ | Branch (595:17): [True: 3.08M, False: 43.8k] ------------------ 596| 3.08M| igraph_integer_t pos = VECTOR(rank)[i]; ------------------ | | 69| 3.08M|#define VECTOR(v) ((v).stor_begin) ------------------ 597| 3.08M| igraph_integer_t pos2 = VECTOR(rank)[i + 1]; ------------------ | | 69| 3.08M|#define VECTOR(v) ((v).stor_begin) ------------------ 598| 3.08M| VECTOR(from)[pos] = VECTOR(edges)[i]; ------------------ | | 69| 3.08M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(from)[pos] = VECTOR(edges)[i]; ------------------ | | 69| 3.08M|#define VECTOR(v) ((v).stor_begin) ------------------ 599| 3.08M| VECTOR(to)[pos] = VECTOR(edges)[i + 1]; ------------------ | | 69| 3.08M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(to)[pos] = VECTOR(edges)[i + 1]; ------------------ | | 69| 3.08M|#define VECTOR(v) ((v).stor_begin) ------------------ 600| 3.08M| VECTOR(from)[pos2] = VECTOR(edges)[i + 1]; ------------------ | | 69| 3.08M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(from)[pos2] = VECTOR(edges)[i + 1]; ------------------ | | 69| 3.08M|#define VECTOR(v) ((v).stor_begin) ------------------ 601| 3.08M| VECTOR(to)[pos2] = VECTOR(edges)[i]; ------------------ | | 69| 3.08M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(to)[pos2] = VECTOR(edges)[i]; ------------------ | | 69| 3.08M|#define VECTOR(v) ((v).stor_begin) ------------------ 602| 3.08M| VECTOR(rev)[pos] = pos2; ------------------ | | 69| 3.08M|#define VECTOR(v) ((v).stor_begin) ------------------ 603| 3.08M| VECTOR(rev)[pos2] = pos; ------------------ | | 69| 3.08M|#define VECTOR(v) ((v).stor_begin) ------------------ 604| 3.08M| VECTOR(rescap)[pos] = capacity ? VECTOR(*capacity)[i / 2] : 1.0; ------------------ | | 69| 3.08M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(rescap)[pos] = capacity ? VECTOR(*capacity)[i / 2] : 1.0; ------------------ | | 69| 3.08M|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (604:31): [True: 3.08M, False: 0] ------------------ 605| 3.08M| VECTOR(rescap)[pos2] = 0.0; ------------------ | | 69| 3.08M|#define VECTOR(v) ((v).stor_begin) ------------------ 606| 3.08M| } 607| | 608| | /* The first pointers. This is a but trickier, than one would 609| | think, because of the possible isolate vertices. */ 610| | 611| 43.8k| idx = -1; 612| 87.6k| for (i = 0; i <= VECTOR(from)[0]; i++) { ------------------ | | 69| 87.6k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (612:17): [True: 43.8k, False: 43.8k] ------------------ 613| 43.8k| idx++; VECTOR(first)[idx] = 0; ------------------ | | 69| 43.8k|#define VECTOR(v) ((v).stor_begin) ------------------ 614| 43.8k| } 615| 6.16M| for (i = 1; i < no_of_edges; i++) { ------------------ | Branch (615:17): [True: 6.11M, False: 43.8k] ------------------ 616| 6.11M| igraph_integer_t n = (VECTOR(from)[i] - ------------------ | | 69| 6.11M|#define VECTOR(v) ((v).stor_begin) ------------------ 617| 6.11M| VECTOR(from)[ VECTOR(first)[idx] ]); ------------------ | | 69| 6.11M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(from)[ VECTOR(first)[idx] ]); ------------------ | | 69| 6.11M|#define VECTOR(v) ((v).stor_begin) ------------------ 618| 7.21M| for (j = 0; j < n; j++) { ------------------ | Branch (618:21): [True: 1.09M, False: 6.11M] ------------------ 619| 1.09M| idx++; VECTOR(first)[idx] = i; ------------------ | | 69| 1.09M|#define VECTOR(v) ((v).stor_begin) ------------------ 620| 1.09M| } 621| 6.11M| } 622| 43.8k| idx++; 623| 87.6k| while (idx < no_of_nodes + 1) { ------------------ | Branch (623:12): [True: 43.8k, False: 43.8k] ------------------ 624| 43.8k| VECTOR(first)[idx++] = no_of_edges; ------------------ | | 69| 43.8k|#define VECTOR(v) ((v).stor_begin) ------------------ 625| 43.8k| } 626| | 627| 43.8k| igraph_vector_int_destroy(&from); 628| 43.8k| igraph_vector_int_destroy(&edges); 629| 43.8k| IGRAPH_FINALLY_CLEAN(2); 630| | 631| 43.8k| if (!flow) { ------------------ | Branch (631:9): [True: 29.4k, False: 14.3k] ------------------ 632| 29.4k| igraph_vector_int_destroy(&rank); 633| 29.4k| IGRAPH_FINALLY_CLEAN(1); 634| 29.4k| } 635| | 636| | /* And the current pointers, initially the same as the first */ 637| 43.8k| IGRAPH_VECTOR_INT_INIT_FINALLY(¤t, no_of_nodes); ------------------ | | 124| 43.8k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 43.8k| do { \ | | | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 43.8k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 43.8k| do { \ | | | | 696| 43.8k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 43.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 43.8k| * incorrect destructor function with the pointer */ \ | | | | 699| 43.8k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 43.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 43.8k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 638| 1.18M| for (i = 0; i < no_of_nodes; i++) { ------------------ | Branch (638:17): [True: 1.14M, False: 43.8k] ------------------ 639| 1.14M| VECTOR(current)[i] = VECTOR(first)[i]; ------------------ | | 69| 1.14M|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(current)[i] = VECTOR(first)[i]; ------------------ | | 69| 1.14M|#define VECTOR(v) ((v).stor_begin) ------------------ 640| 1.14M| } 641| | 642| | /* OK, the graph is set up, initialization */ 643| | 644| 43.8k| IGRAPH_CHECK(igraph_buckets_init(&buckets, no_of_nodes + 1, no_of_nodes)); ------------------ | | 752| 43.8k| do { \ | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 43.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 645| 43.8k| IGRAPH_FINALLY(igraph_buckets_destroy, &buckets); ------------------ | | 695| 43.8k| do { \ | | 696| 43.8k| /* the following branch makes the compiler check the compatibility of \ | | 697| 43.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 43.8k| * incorrect destructor function with the pointer */ \ | | 699| 43.8k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 43.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 43.8k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 646| 43.8k| IGRAPH_CHECK(igraph_dbuckets_init(&ibuckets, no_of_nodes + 1, no_of_nodes)); ------------------ | | 752| 43.8k| do { \ | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 43.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 647| 43.8k| IGRAPH_FINALLY(igraph_dbuckets_destroy, &ibuckets); ------------------ | | 695| 43.8k| do { \ | | 696| 43.8k| /* the following branch makes the compiler check the compatibility of \ | | 697| 43.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 43.8k| * incorrect destructor function with the pointer */ \ | | 699| 43.8k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 43.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 43.8k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 648| | 649| | /* Send as much flow as possible from the source to its neighbors */ 650| 311k| for (i = FIRST(source), j = LAST(source); i < j; i++) { ------------------ | | 569| 43.8k|#define FIRST(i) (VECTOR(first)[(i)]) | | ------------------ | | | | 69| 43.8k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ for (i = FIRST(source), j = LAST(source); i < j; i++) { ------------------ | | 570| 43.8k|#define LAST(i) (VECTOR(first)[(i)+1]) | | ------------------ | | | | 69| 43.8k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (650:47): [True: 267k, False: 43.8k] ------------------ 651| 267k| if (HEAD(i) != source) { ------------------ | | 574| 267k|#define HEAD(i) (VECTOR(to)[(i)]) | | ------------------ | | | | 69| 267k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (651:13): [True: 267k, False: 0] ------------------ 652| 267k| igraph_real_t delta = RESCAP(i); ------------------ | | 572| 267k|#define RESCAP(i) (VECTOR(rescap)[(i)]) | | ------------------ | | | | 69| 267k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 653| 267k| RESCAP(i) = 0; ------------------ | | 572| 267k|#define RESCAP(i) (VECTOR(rescap)[(i)]) | | ------------------ | | | | 69| 267k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 654| 267k| RESCAP(REV(i)) += delta; ------------------ | | 572| 267k|#define RESCAP(i) (VECTOR(rescap)[(i)]) | | ------------------ | | | | 69| 267k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 655| 267k| EXCESS(HEAD(i)) += delta; ------------------ | | 575| 267k|#define EXCESS(i) (VECTOR(excess)[(i)]) | | ------------------ | | | | 69| 267k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 656| 267k| } 657| 267k| } 658| | 659| 43.8k| IGRAPH_CHECK(BFS()); ------------------ | | 752| 43.8k| do { \ | | 753| 43.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 43.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 43.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 43.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 43.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 660| 43.8k| (stats->nobfs)++; 661| | 662| 1.14M| while (!igraph_buckets_empty(&buckets)) { ------------------ | Branch (662:12): [True: 1.10M, False: 43.8k] ------------------ 663| 1.10M| igraph_integer_t vertex = igraph_buckets_popmax(&buckets); 664| 1.10M| DISCHARGE(vertex); ------------------ | | 236| 1.10M|#define DISCHARGE(v) (igraph_i_mf_discharge((v), ¤t, &first, &rescap, \ | | 237| 1.10M| &to, &distance, &excess, \ | | 238| 1.10M| no_of_nodes, source, target, \ | | 239| 1.10M| &buckets, &ibuckets, \ | | 240| 1.10M| &rev, stats, &npushsince, \ | | 241| 1.10M| &nrelabelsince)) ------------------ 665| 1.10M| if (npushsince > no_of_nodes / 2 && nrelabelsince > no_of_nodes) { ------------------ | Branch (665:13): [True: 578k, False: 526k] | Branch (665:45): [True: 1.89k, False: 576k] ------------------ 666| 1.89k| (stats->nobfs)++; 667| 1.89k| BFS(); ------------------ | | 251| 1.89k|#define BFS() (igraph_i_mf_bfs(&bfsq, source, target, no_of_nodes, \ | | 252| 1.89k| &buckets, &ibuckets, &distance, \ | | 253| 1.89k| &first, ¤t, &to, &excess, \ | | 254| 1.89k| &rescap, &rev)) ------------------ 668| 1.89k| npushsince = nrelabelsince = 0; 669| 1.89k| } 670| 1.10M| } 671| | 672| | /* Store the result */ 673| 43.8k| if (value) { ------------------ | Branch (673:9): [True: 38.4k, False: 5.36k] ------------------ 674| 38.4k| *value = EXCESS(target); ------------------ | | 575| 38.4k|#define EXCESS(i) (VECTOR(excess)[(i)]) | | ------------------ | | | | 69| 38.4k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 675| 38.4k| } 676| | 677| | /* If we also need the minimum cut */ 678| 43.8k| if (cut || partition || partition2) { ------------------ | Branch (678:9): [True: 0, False: 43.8k] | Branch (678:16): [True: 0, False: 43.8k] | Branch (678:29): [True: 0, False: 43.8k] ------------------ 679| | /* We need to find all vertices from which the target is reachable 680| | in the residual graph. We do a breadth-first search, going 681| | backwards. */ 682| 0| igraph_dqueue_int_t Q; 683| 0| igraph_vector_bool_t added; 684| 0| igraph_integer_t marked = 0; 685| | 686| 0| IGRAPH_CHECK(igraph_vector_bool_init(&added, no_of_nodes)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 687| 0| IGRAPH_FINALLY(igraph_vector_bool_destroy, &added); ------------------ | | 695| 0| do { \ | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 0| * incorrect destructor function with the pointer */ \ | | 699| 0| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 0| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 688| | 689| 0| IGRAPH_CHECK(igraph_dqueue_int_init(&Q, 100)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 690| 0| IGRAPH_FINALLY(igraph_dqueue_int_destroy, &Q); ------------------ | | 695| 0| do { \ | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 0| * incorrect destructor function with the pointer */ \ | | 699| 0| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 0| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 691| | 692| 0| IGRAPH_CHECK(igraph_dqueue_int_push(&Q, target)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 693| 0| VECTOR(added)[target] = true; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 694| 0| marked++; 695| 0| while (!igraph_dqueue_int_empty(&Q)) { ------------------ | Branch (695:16): [True: 0, False: 0] ------------------ 696| 0| igraph_integer_t actnode = igraph_dqueue_int_pop(&Q); 697| 0| for (i = FIRST(actnode), j = LAST(actnode); i < j; i++) { ------------------ | | 569| 0|#define FIRST(i) (VECTOR(first)[(i)]) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ for (i = FIRST(actnode), j = LAST(actnode); i < j; i++) { ------------------ | | 570| 0|#define LAST(i) (VECTOR(first)[(i)+1]) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (697:57): [True: 0, False: 0] ------------------ 698| 0| igraph_integer_t nei = HEAD(i); ------------------ | | 574| 0|#define HEAD(i) (VECTOR(to)[(i)]) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 699| 0| if (!VECTOR(added)[nei] && RESCAP(REV(i)) > 0.0) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ if (!VECTOR(added)[nei] && RESCAP(REV(i)) > 0.0) { ------------------ | | 572| 0|#define RESCAP(i) (VECTOR(rescap)[(i)]) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (699:21): [True: 0, False: 0] | Branch (699:44): [True: 0, False: 0] ------------------ 700| 0| VECTOR(added)[nei] = true; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 701| 0| marked++; 702| 0| IGRAPH_CHECK(igraph_dqueue_int_push(&Q, nei)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 703| 0| } 704| 0| } 705| 0| } 706| 0| igraph_dqueue_int_destroy(&Q); 707| 0| IGRAPH_FINALLY_CLEAN(1); 708| | 709| | /* Now we marked each vertex that is on one side of the cut, 710| | check the crossing edges */ 711| | 712| 0| if (cut) { ------------------ | Branch (712:13): [True: 0, False: 0] ------------------ 713| 0| igraph_vector_int_clear(cut); 714| 0| for (i = 0; i < no_of_orig_edges; i++) { ------------------ | Branch (714:25): [True: 0, False: 0] ------------------ 715| 0| igraph_integer_t f = IGRAPH_FROM(graph, i); ------------------ | | 103| 0|#define IGRAPH_FROM(graph,eid) ((igraph_integer_t)(VECTOR((graph)->from)[(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 716| 0| igraph_integer_t t = IGRAPH_TO(graph, i); ------------------ | | 116| 0|#define IGRAPH_TO(graph,eid) ((igraph_integer_t)(VECTOR((graph)->to) [(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 717| 0| if (!VECTOR(added)[f] && VECTOR(added)[t]) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ if (!VECTOR(added)[f] && VECTOR(added)[t]) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (717:21): [True: 0, False: 0] | Branch (717:42): [True: 0, False: 0] ------------------ 718| 0| IGRAPH_CHECK(igraph_vector_int_push_back(cut, i)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 719| 0| } 720| 0| } 721| 0| } 722| | 723| 0| if (partition2) { ------------------ | Branch (723:13): [True: 0, False: 0] ------------------ 724| 0| igraph_integer_t x = 0; 725| 0| IGRAPH_CHECK(igraph_vector_int_resize(partition2, marked)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 726| 0| for (i = 0; i < no_of_nodes; i++) { ------------------ | Branch (726:25): [True: 0, False: 0] ------------------ 727| 0| if (VECTOR(added)[i]) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (727:21): [True: 0, False: 0] ------------------ 728| 0| VECTOR(*partition2)[x++] = i; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 729| 0| } 730| 0| } 731| 0| } 732| | 733| 0| if (partition) { ------------------ | Branch (733:13): [True: 0, False: 0] ------------------ 734| 0| igraph_integer_t x = 0; 735| 0| IGRAPH_CHECK(igraph_vector_int_resize(partition, ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 736| 0| no_of_nodes - marked)); 737| 0| for (i = 0; i < no_of_nodes; i++) { ------------------ | Branch (737:25): [True: 0, False: 0] ------------------ 738| 0| if (!VECTOR(added)[i]) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (738:21): [True: 0, False: 0] ------------------ 739| 0| VECTOR(*partition)[x++] = i; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 740| 0| } 741| 0| } 742| 0| } 743| | 744| 0| igraph_vector_bool_destroy(&added); 745| 0| IGRAPH_FINALLY_CLEAN(1); 746| 0| } 747| | 748| 43.8k| if (flow) { ------------------ | Branch (748:9): [True: 14.3k, False: 29.4k] ------------------ 749| | /* Initialize the backward distances, with a breadth-first search 750| | from the source */ 751| 14.3k| igraph_dqueue_int_t Q; 752| 14.3k| igraph_vector_int_t added; 753| 14.3k| igraph_integer_t j, k, l; 754| 14.3k| igraph_t flow_graph; 755| 14.3k| igraph_vector_int_t flow_edges; 756| 14.3k| igraph_bool_t dag; 757| | 758| 14.3k| IGRAPH_CHECK(igraph_vector_int_init(&added, no_of_nodes)); ------------------ | | 752| 14.3k| do { \ | | 753| 14.3k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 14.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 14.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 14.3k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 14.3k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 759| 14.3k| IGRAPH_FINALLY(igraph_vector_int_destroy, &added); ------------------ | | 695| 14.3k| do { \ | | 696| 14.3k| /* the following branch makes the compiler check the compatibility of \ | | 697| 14.3k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 14.3k| * incorrect destructor function with the pointer */ \ | | 699| 14.3k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 14.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 14.3k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 760| 14.3k| IGRAPH_CHECK(igraph_dqueue_int_init(&Q, 100)); ------------------ | | 752| 14.3k| do { \ | | 753| 14.3k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 14.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 14.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 14.3k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 14.3k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 761| 14.3k| IGRAPH_FINALLY(igraph_dqueue_int_destroy, &Q); ------------------ | | 695| 14.3k| do { \ | | 696| 14.3k| /* the following branch makes the compiler check the compatibility of \ | | 697| 14.3k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 14.3k| * incorrect destructor function with the pointer */ \ | | 699| 14.3k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 14.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 14.3k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 762| | 763| 14.3k| IGRAPH_CHECK(igraph_dqueue_int_push(&Q, source)); ------------------ | | 752| 14.3k| do { \ | | 753| 14.3k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 14.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 14.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 14.3k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 14.3k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 764| 14.3k| IGRAPH_CHECK(igraph_dqueue_int_push(&Q, 0)); ------------------ | | 752| 14.3k| do { \ | | 753| 14.3k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 14.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 14.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 14.3k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 14.3k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 765| 14.3k| VECTOR(added)[source] = 1; ------------------ | | 69| 14.3k|#define VECTOR(v) ((v).stor_begin) ------------------ 766| 372k| while (!igraph_dqueue_int_empty(&Q)) { ------------------ | Branch (766:16): [True: 358k, False: 14.3k] ------------------ 767| 358k| igraph_integer_t actnode = igraph_dqueue_int_pop(&Q); 768| 358k| igraph_integer_t actdist = igraph_dqueue_int_pop(&Q); 769| 358k| DIST(actnode) = actdist; ------------------ | | 576| 358k|#define DIST(i) (VECTOR(distance)[(i)]) | | ------------------ | | | | 69| 358k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 770| | 771| 2.35M| for (i = FIRST(actnode), j = LAST(actnode); i < j; i++) { ------------------ | | 569| 358k|#define FIRST(i) (VECTOR(first)[(i)]) | | ------------------ | | | | 69| 358k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ for (i = FIRST(actnode), j = LAST(actnode); i < j; i++) { ------------------ | | 570| 358k|#define LAST(i) (VECTOR(first)[(i)+1]) | | ------------------ | | | | 69| 358k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (771:57): [True: 1.99M, False: 358k] ------------------ 772| 1.99M| igraph_integer_t nei = HEAD(i); ------------------ | | 574| 1.99M|#define HEAD(i) (VECTOR(to)[(i)]) | | ------------------ | | | | 69| 1.99M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 773| 1.99M| if (!VECTOR(added)[nei] && RESCAP(REV(i)) > 0.0) { ------------------ | | 69| 1.99M|#define VECTOR(v) ((v).stor_begin) ------------------ if (!VECTOR(added)[nei] && RESCAP(REV(i)) > 0.0) { ------------------ | | 572| 420k|#define RESCAP(i) (VECTOR(rescap)[(i)]) | | ------------------ | | | | 69| 420k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (773:21): [True: 420k, False: 1.57M] | Branch (773:44): [True: 343k, False: 77.1k] ------------------ 774| 343k| VECTOR(added)[nei] = 1; ------------------ | | 69| 343k|#define VECTOR(v) ((v).stor_begin) ------------------ 775| 343k| IGRAPH_CHECK(igraph_dqueue_int_push(&Q, nei)); ------------------ | | 752| 343k| do { \ | | 753| 343k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 343k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 343k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 343k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 343k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 776| 343k| IGRAPH_CHECK(igraph_dqueue_int_push(&Q, actdist + 1)); ------------------ | | 752| 343k| do { \ | | 753| 343k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 343k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 343k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 343k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 343k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 777| 343k| } 778| 1.99M| } 779| 358k| } /* !igraph_dqueue_int_empty(&Q) */ 780| | 781| 14.3k| igraph_vector_int_destroy(&added); 782| 14.3k| igraph_dqueue_int_destroy(&Q); 783| 14.3k| IGRAPH_FINALLY_CLEAN(2); 784| | 785| | /* Reinitialize the buckets */ 786| 14.3k| igraph_buckets_clear(&buckets); 787| 372k| for (i = 0; i < no_of_nodes; i++) { ------------------ | Branch (787:21): [True: 358k, False: 14.3k] ------------------ 788| 358k| if (EXCESS(i) > 0.0 && i != source && i != target) { ------------------ | | 575| 358k|#define EXCESS(i) (VECTOR(excess)[(i)]) | | ------------------ | | | | 69| 358k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (788:17): [True: 150k, False: 208k] | Branch (788:36): [True: 150k, False: 0] | Branch (788:51): [True: 135k, False: 14.3k] ------------------ 789| 135k| igraph_buckets_add(&buckets, DIST(i), i); ------------------ | | 576| 135k|#define DIST(i) (VECTOR(distance)[(i)]) | | ------------------ | | | | 69| 135k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 790| 135k| } 791| 358k| } 792| | 793| | /* Now we return the flow to the source */ 794| 257k| while (!igraph_buckets_empty(&buckets)) { ------------------ | Branch (794:16): [True: 242k, False: 14.3k] ------------------ 795| 242k| igraph_integer_t vertex = igraph_buckets_popmax(&buckets); 796| | 797| | /* DISCHARGE(vertex) comes here */ 798| 242k| do { 799| 722k| for (i = CURRENT(vertex), j = LAST(vertex); i < j; i++) { ------------------ | | 571| 242k|#define CURRENT(i) (VECTOR(current)[(i)]) | | ------------------ | | | | 69| 242k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ for (i = CURRENT(vertex), j = LAST(vertex); i < j; i++) { ------------------ | | 570| 242k|#define LAST(i) (VECTOR(first)[(i)+1]) | | ------------------ | | | | 69| 242k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (799:61): [True: 677k, False: 44.3k] ------------------ 800| 677k| if (RESCAP(i) > 0) { ------------------ | | 572| 677k|#define RESCAP(i) (VECTOR(rescap)[(i)]) | | ------------------ | | | | 69| 677k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (800:25): [True: 375k, False: 302k] ------------------ 801| 375k| igraph_integer_t nei = HEAD(i); ------------------ | | 574| 375k|#define HEAD(i) (VECTOR(to)[(i)]) | | ------------------ | | | | 69| 375k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 802| | 803| 375k| if (DIST(vertex) == DIST(nei) + 1) { ------------------ | | 576| 375k|#define DIST(i) (VECTOR(distance)[(i)]) | | ------------------ | | | | 69| 375k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ if (DIST(vertex) == DIST(nei) + 1) { ------------------ | | 576| 375k|#define DIST(i) (VECTOR(distance)[(i)]) | | ------------------ | | | | 69| 375k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (803:29): [True: 229k, False: 146k] ------------------ 804| 229k| igraph_real_t delta = 805| 229k| RESCAP(i) < EXCESS(vertex) ? RESCAP(i) : EXCESS(vertex); ------------------ | | 572| 229k|#define RESCAP(i) (VECTOR(rescap)[(i)]) | | ------------------ | | | | 69| 229k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ RESCAP(i) < EXCESS(vertex) ? RESCAP(i) : EXCESS(vertex); ------------------ | | 575| 229k|#define EXCESS(i) (VECTOR(excess)[(i)]) | | ------------------ | | | | 69| 229k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ RESCAP(i) < EXCESS(vertex) ? RESCAP(i) : EXCESS(vertex); ------------------ | | 572| 31.0k|#define RESCAP(i) (VECTOR(rescap)[(i)]) | | ------------------ | | | | 69| 31.0k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ RESCAP(i) < EXCESS(vertex) ? RESCAP(i) : EXCESS(vertex); ------------------ | | 575| 198k|#define EXCESS(i) (VECTOR(excess)[(i)]) | | ------------------ | | | | 69| 198k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (805:33): [True: 31.0k, False: 198k] ------------------ 806| 229k| RESCAP(i) -= delta; ------------------ | | 572| 229k|#define RESCAP(i) (VECTOR(rescap)[(i)]) | | ------------------ | | | | 69| 229k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 807| 229k| RESCAP(REV(i)) += delta; ------------------ | | 572| 229k|#define RESCAP(i) (VECTOR(rescap)[(i)]) | | ------------------ | | | | 69| 229k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 808| | 809| 229k| if (nei != source && EXCESS(nei) == 0.0 && ------------------ | | 575| 109k|#define EXCESS(i) (VECTOR(excess)[(i)]) | | ------------------ | | | | 69| 109k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (809:33): [True: 109k, False: 120k] | Branch (809:50): [True: 62.8k, False: 46.4k] ------------------ 810| 229k| DIST(nei) != no_of_nodes) { ------------------ | | 576| 62.8k|#define DIST(i) (VECTOR(distance)[(i)]) | | ------------------ | | | | 69| 62.8k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (810:33): [True: 62.8k, False: 0] ------------------ 811| 62.8k| igraph_buckets_add(&buckets, DIST(nei), nei); ------------------ | | 576| 62.8k|#define DIST(i) (VECTOR(distance)[(i)]) | | ------------------ | | | | 69| 62.8k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 812| 62.8k| } 813| | 814| 229k| EXCESS(nei) += delta; ------------------ | | 575| 229k|#define EXCESS(i) (VECTOR(excess)[(i)]) | | ------------------ | | | | 69| 229k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 815| 229k| EXCESS(vertex) -= delta; ------------------ | | 575| 229k|#define EXCESS(i) (VECTOR(excess)[(i)]) | | ------------------ | | | | 69| 229k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 816| | 817| 229k| if (EXCESS(vertex) == 0) { ------------------ | | 575| 229k|#define EXCESS(i) (VECTOR(excess)[(i)]) | | ------------------ | | | | 69| 229k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (817:33): [True: 198k, False: 31.0k] ------------------ 818| 198k| break; 819| 198k| } 820| | 821| 229k| } 822| 375k| } 823| 677k| } 824| | 825| 242k| if (i == j) { ------------------ | Branch (825:21): [True: 44.3k, False: 198k] ------------------ 826| | 827| | /* RELABEL(vertex) comes here */ 828| 44.3k| igraph_integer_t min; 829| 44.3k| igraph_integer_t min_edge = 0; 830| 44.3k| DIST(vertex) = min = no_of_nodes; ------------------ | | 576| 44.3k|#define DIST(i) (VECTOR(distance)[(i)]) | | ------------------ | | | | 69| 44.3k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 831| 324k| for (k = FIRST(vertex), l = LAST(vertex); k < l; k++) { ------------------ | | 569| 44.3k|#define FIRST(i) (VECTOR(first)[(i)]) | | ------------------ | | | | 69| 44.3k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ for (k = FIRST(vertex), l = LAST(vertex); k < l; k++) { ------------------ | | 570| 44.3k|#define LAST(i) (VECTOR(first)[(i)+1]) | | ------------------ | | | | 69| 44.3k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (831:63): [True: 280k, False: 44.3k] ------------------ 832| 280k| if (RESCAP(k) > 0) { ------------------ | | 572| 280k|#define RESCAP(i) (VECTOR(rescap)[(i)]) | | ------------------ | | | | 69| 280k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (832:29): [True: 115k, False: 164k] ------------------ 833| 115k| if (DIST(HEAD(k)) < min) { ------------------ | | 576| 115k|#define DIST(i) (VECTOR(distance)[(i)]) | | ------------------ | | | | 69| 115k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (833:33): [True: 45.0k, False: 70.6k] ------------------ 834| 45.0k| min = DIST(HEAD(k)); ------------------ | | 576| 45.0k|#define DIST(i) (VECTOR(distance)[(i)]) | | ------------------ | | | | 69| 45.0k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 835| 45.0k| min_edge = k; 836| 45.0k| } 837| 115k| } 838| 280k| } 839| | 840| 44.3k| min++; 841| | 842| 44.3k| if (min < no_of_nodes) { ------------------ | Branch (842:25): [True: 44.3k, False: 0] ------------------ 843| 44.3k| DIST(vertex) = min; ------------------ | | 576| 44.3k|#define DIST(i) (VECTOR(distance)[(i)]) | | ------------------ | | | | 69| 44.3k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 844| 44.3k| CURRENT(vertex) = min_edge; ------------------ | | 571| 44.3k|#define CURRENT(i) (VECTOR(current)[(i)]) | | ------------------ | | | | 69| 44.3k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 845| | /* Vertex is still active */ 846| 44.3k| igraph_buckets_add(&buckets, DIST(vertex), vertex); ------------------ | | 576| 44.3k|#define DIST(i) (VECTOR(distance)[(i)]) | | ------------------ | | | | 69| 44.3k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 847| 44.3k| } 848| | 849| | /* TODO: gap heuristics here ??? */ 850| | 851| 198k| } else { 852| 198k| CURRENT(vertex) = FIRST(vertex); ------------------ | | 571| 198k|#define CURRENT(i) (VECTOR(current)[(i)]) | | ------------------ | | | | 69| 198k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ CURRENT(vertex) = FIRST(vertex); ------------------ | | 569| 198k|#define FIRST(i) (VECTOR(first)[(i)]) | | ------------------ | | | | 69| 198k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 853| 198k| } 854| | 855| 242k| break; 856| | 857| 242k| } while (true); 858| 242k| } 859| | 860| | /* We need to eliminate flow cycles now. Before that we check that 861| | there is a cycle in the flow graph. 862| | 863| | First we do a couple of DFSes from the source vertex to the 864| | target and factor out the paths we find. If there is no more 865| | path to the target, then all remaining flow must be in flow 866| | cycles, so we don't need it at all. 867| | 868| | Some details. 'stack' contains the whole path of the DFS, both 869| | the vertices and the edges, they are alternating in the stack. 870| | 'current' helps finding the next outgoing edge of a vertex 871| | quickly, the next edge of 'v' is FIRST(v)+CURRENT(v). If this 872| | is LAST(v), then there are no more edges to try. 873| | 874| | The 'added' vector contains 0 if the vertex was not visited 875| | before, 1 if it is currently in 'stack', and 2 if it is not in 876| | 'stack', but it was visited before. */ 877| | 878| 14.3k| IGRAPH_VECTOR_INT_INIT_FINALLY(&flow_edges, 0); ------------------ | | 124| 14.3k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 14.3k| do { \ | | | | 753| 14.3k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 14.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 14.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 14.3k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 14.3k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 14.3k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 14.3k| do { \ | | | | 696| 14.3k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 14.3k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 14.3k| * incorrect destructor function with the pointer */ \ | | | | 699| 14.3k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 14.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 14.3k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 879| 1.01M| for (i = 0, j = 0; i < no_of_edges; i += 2, j++) { ------------------ | Branch (879:28): [True: 997k, False: 14.3k] ------------------ 880| 997k| igraph_integer_t pos = VECTOR(rank)[i]; ------------------ | | 69| 997k|#define VECTOR(v) ((v).stor_begin) ------------------ 881| 997k| if ((capacity ? VECTOR(*capacity)[j] : 1.0) > RESCAP(pos)) { ------------------ | | 69| 997k|#define VECTOR(v) ((v).stor_begin) ------------------ if ((capacity ? VECTOR(*capacity)[j] : 1.0) > RESCAP(pos)) { ------------------ | | 572| 997k|#define RESCAP(i) (VECTOR(rescap)[(i)]) | | ------------------ | | | | 69| 997k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (881:17): [True: 322k, False: 674k] | Branch (881:18): [True: 997k, False: 0] ------------------ 882| 322k| IGRAPH_CHECK(igraph_vector_int_push_back(&flow_edges, ------------------ | | 752| 322k| do { \ | | 753| 322k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 322k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 322k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 322k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 322k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 883| 322k| IGRAPH_FROM(graph, j))); 884| 322k| IGRAPH_CHECK(igraph_vector_int_push_back(&flow_edges, ------------------ | | 752| 322k| do { \ | | 753| 322k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 322k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 322k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 322k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 322k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 885| 322k| IGRAPH_TO(graph, j))); 886| 322k| } 887| 997k| } 888| 14.3k| IGRAPH_CHECK(igraph_create(&flow_graph, &flow_edges, no_of_nodes, ------------------ | | 752| 14.3k| do { \ | | 753| 14.3k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 14.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 14.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 14.3k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 14.3k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 889| 14.3k| IGRAPH_DIRECTED)); 890| 14.3k| igraph_vector_int_destroy(&flow_edges); 891| 14.3k| IGRAPH_FINALLY_CLEAN(1); 892| 14.3k| IGRAPH_FINALLY(igraph_destroy, &flow_graph); ------------------ | | 695| 14.3k| do { \ | | 696| 14.3k| /* the following branch makes the compiler check the compatibility of \ | | 697| 14.3k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 14.3k| * incorrect destructor function with the pointer */ \ | | 699| 14.3k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 14.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 14.3k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 893| 14.3k| IGRAPH_CHECK(igraph_is_dag(&flow_graph, &dag)); ------------------ | | 752| 14.3k| do { \ | | 753| 14.3k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 14.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 14.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 14.3k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 14.3k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 894| 14.3k| igraph_destroy(&flow_graph); 895| 14.3k| IGRAPH_FINALLY_CLEAN(1); 896| | 897| 14.3k| if (!dag) { ------------------ | Branch (897:13): [True: 8.11k, False: 6.27k] ------------------ 898| 8.11k| igraph_vector_int_t stack; 899| 8.11k| igraph_vector_t mycap; 900| | 901| 8.11k| IGRAPH_CHECK(igraph_vector_int_init(&stack, 0)); ------------------ | | 752| 8.11k| do { \ | | 753| 8.11k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 8.11k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 8.11k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 8.11k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 8.11k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 902| 8.11k| IGRAPH_FINALLY(igraph_vector_int_destroy, &stack); ------------------ | | 695| 8.11k| do { \ | | 696| 8.11k| /* the following branch makes the compiler check the compatibility of \ | | 697| 8.11k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 8.11k| * incorrect destructor function with the pointer */ \ | | 699| 8.11k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 8.11k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 8.11k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 903| 8.11k| IGRAPH_CHECK(igraph_vector_int_init(&added, no_of_nodes)); ------------------ | | 752| 8.11k| do { \ | | 753| 8.11k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 8.11k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 8.11k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 8.11k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 8.11k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 904| 8.11k| IGRAPH_FINALLY(igraph_vector_int_destroy, &added); ------------------ | | 695| 8.11k| do { \ | | 696| 8.11k| /* the following branch makes the compiler check the compatibility of \ | | 697| 8.11k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 8.11k| * incorrect destructor function with the pointer */ \ | | 699| 8.11k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 8.11k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 8.11k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 905| 8.11k| IGRAPH_VECTOR_INIT_FINALLY(&mycap, no_of_edges); ------------------ | | 109| 8.11k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \ | | ------------------ | | | | 752| 8.11k| do { \ | | | | 753| 8.11k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 8.11k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 8.11k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 8.11k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 8.11k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 110| 8.11k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0) | | ------------------ | | | | 695| 8.11k| do { \ | | | | 696| 8.11k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 8.11k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 8.11k| * incorrect destructor function with the pointer */ \ | | | | 699| 8.11k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 8.11k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 8.11k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (110:60): [Folded - Ignored] | | ------------------ ------------------ 906| | 907| 8.11k|#define MYCAP(i) (VECTOR(mycap)[(i)]) 908| | 909| 611k| for (i = 0; i < no_of_edges; i += 2) { ------------------ | Branch (909:25): [True: 603k, False: 8.11k] ------------------ 910| 603k| igraph_integer_t pos = VECTOR(rank)[i]; ------------------ | | 69| 603k|#define VECTOR(v) ((v).stor_begin) ------------------ 911| 603k| igraph_integer_t pos2 = VECTOR(rank)[i + 1]; ------------------ | | 69| 603k|#define VECTOR(v) ((v).stor_begin) ------------------ 912| 603k| MYCAP(pos) = (capacity ? VECTOR(*capacity)[i / 2] : 1.0) - RESCAP(pos); ------------------ | | 907| 603k|#define MYCAP(i) (VECTOR(mycap)[(i)]) | | ------------------ | | | | 69| 603k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ MYCAP(pos) = (capacity ? VECTOR(*capacity)[i / 2] : 1.0) - RESCAP(pos); ------------------ | | 69| 603k|#define VECTOR(v) ((v).stor_begin) ------------------ MYCAP(pos) = (capacity ? VECTOR(*capacity)[i / 2] : 1.0) - RESCAP(pos); ------------------ | | 572| 603k|#define RESCAP(i) (VECTOR(rescap)[(i)]) | | ------------------ | | | | 69| 603k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (912:31): [True: 603k, False: 0] ------------------ 913| 603k| MYCAP(pos2) = 0.0; ------------------ | | 907| 603k|#define MYCAP(i) (VECTOR(mycap)[(i)]) | | ------------------ | | | | 69| 603k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 914| 603k| } 915| | 916| 32.2k| do { 917| 32.2k| igraph_vector_int_null(¤t); 918| 32.2k| igraph_vector_int_clear(&stack); 919| 32.2k| igraph_vector_int_null(&added); 920| | 921| 32.2k| IGRAPH_CHECK(igraph_vector_int_push_back(&stack, -1)); ------------------ | | 752| 32.2k| do { \ | | 753| 32.2k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 32.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 32.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 32.2k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 32.2k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 922| 32.2k| IGRAPH_CHECK(igraph_vector_int_push_back(&stack, source)); ------------------ | | 752| 32.2k| do { \ | | 753| 32.2k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 32.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 32.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 32.2k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 32.2k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 923| 32.2k| VECTOR(added)[source] = 1; ------------------ | | 69| 32.2k|#define VECTOR(v) ((v).stor_begin) ------------------ 924| 239k| while (!igraph_vector_int_empty(&stack) && ------------------ | Branch (924:24): [True: 231k, False: 8.11k] ------------------ 925| 239k| igraph_vector_int_tail(&stack) != target) { ------------------ | Branch (925:24): [True: 207k, False: 24.1k] ------------------ 926| 207k| igraph_integer_t actnode = igraph_vector_int_tail(&stack); 927| 207k| igraph_integer_t edge = FIRST(actnode) + CURRENT(actnode); ------------------ | | 569| 207k|#define FIRST(i) (VECTOR(first)[(i)]) | | ------------------ | | | | 69| 207k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ igraph_integer_t edge = FIRST(actnode) + CURRENT(actnode); ------------------ | | 571| 207k|#define CURRENT(i) (VECTOR(current)[(i)]) | | ------------------ | | | | 69| 207k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 928| 207k| igraph_integer_t nei; 929| 1.06M| while (edge < LAST(actnode) && MYCAP(edge) == 0.0) { ------------------ | | 570| 2.12M|#define LAST(i) (VECTOR(first)[(i)+1]) | | ------------------ | | | | 69| 1.06M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ while (edge < LAST(actnode) && MYCAP(edge) == 0.0) { ------------------ | | 907| 1.02M|#define MYCAP(i) (VECTOR(mycap)[(i)]) | | ------------------ | | | | 69| 1.02M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (929:28): [True: 1.02M, False: 36.4k] | Branch (929:52): [True: 854k, False: 171k] ------------------ 930| 854k| edge++; 931| 854k| } 932| 207k| nei = edge < LAST(actnode) ? HEAD(edge) : -1; ------------------ | | 570| 207k|#define LAST(i) (VECTOR(first)[(i)+1]) | | ------------------ | | | | 69| 207k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ nei = edge < LAST(actnode) ? HEAD(edge) : -1; ------------------ | | 574| 171k|#define HEAD(i) (VECTOR(to)[(i)]) | | ------------------ | | | | 69| 171k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (932:27): [True: 171k, False: 36.4k] ------------------ 933| | 934| 207k| if (edge < LAST(actnode) && !VECTOR(added)[nei]) { ------------------ | | 570| 415k|#define LAST(i) (VECTOR(first)[(i)+1]) | | ------------------ | | | | 69| 207k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ if (edge < LAST(actnode) && !VECTOR(added)[nei]) { ------------------ | | 69| 171k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (934:25): [True: 171k, False: 36.4k] | Branch (934:49): [True: 164k, False: 6.44k] ------------------ 935| | /* Go forward along next edge, if the vertex was not 936| | visited before */ 937| 164k| IGRAPH_CHECK(igraph_vector_int_push_back(&stack, edge)); ------------------ | | 752| 164k| do { \ | | 753| 164k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 164k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 164k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 164k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 164k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 938| 164k| IGRAPH_CHECK(igraph_vector_int_push_back(&stack, nei)); ------------------ | | 752| 164k| do { \ | | 753| 164k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 164k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 164k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 164k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 164k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 939| 164k| VECTOR(added)[nei] = 1; ------------------ | | 69| 164k|#define VECTOR(v) ((v).stor_begin) ------------------ 940| 164k| CURRENT(actnode) += 1; ------------------ | | 571| 164k|#define CURRENT(i) (VECTOR(current)[(i)]) | | ------------------ | | | | 69| 164k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 941| 164k| } else if (edge < LAST(actnode) && VECTOR(added)[nei] == 1) { ------------------ | | 570| 85.7k|#define LAST(i) (VECTOR(first)[(i)+1]) | | ------------------ | | | | 69| 42.8k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ } else if (edge < LAST(actnode) && VECTOR(added)[nei] == 1) { ------------------ | | 69| 6.44k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (941:32): [True: 6.44k, False: 36.4k] | Branch (941:56): [True: 6.44k, False: 0] ------------------ 942| | /* We found a flow cycle, factor it out. Go back in stack 943| | until we find 'nei' again, determine the flow along the 944| | cycle. */ 945| 6.44k| igraph_real_t thisflow = MYCAP(edge); ------------------ | | 907| 6.44k|#define MYCAP(i) (VECTOR(mycap)[(i)]) | | ------------------ | | | | 69| 6.44k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 946| 6.44k| igraph_integer_t idx; 947| 6.44k| for (idx = igraph_vector_int_size(&stack) - 2; 948| 34.7k| idx >= 0 && VECTOR(stack)[idx + 1] != nei; idx -= 2) { ------------------ | | 69| 34.7k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (948:30): [True: 34.7k, False: 0] | Branch (948:42): [True: 28.2k, False: 6.44k] ------------------ 949| 28.2k| igraph_integer_t e = VECTOR(stack)[idx]; ------------------ | | 69| 28.2k|#define VECTOR(v) ((v).stor_begin) ------------------ 950| 28.2k| igraph_real_t rcap = e >= 0 ? MYCAP(e) : MYCAP(edge); ------------------ | | 907| 28.2k|#define MYCAP(i) (VECTOR(mycap)[(i)]) | | ------------------ | | | | 69| 28.2k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ igraph_real_t rcap = e >= 0 ? MYCAP(e) : MYCAP(edge); ------------------ | | 907| 0|#define MYCAP(i) (VECTOR(mycap)[(i)]) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (950:50): [True: 28.2k, False: 0] ------------------ 951| 28.2k| if (rcap < thisflow) { ------------------ | Branch (951:33): [True: 0, False: 28.2k] ------------------ 952| 0| thisflow = rcap; 953| 0| } 954| 28.2k| } 955| 6.44k| MYCAP(edge) -= thisflow; RESCAP(edge) += thisflow; ------------------ | | 907| 6.44k|#define MYCAP(i) (VECTOR(mycap)[(i)]) | | ------------------ | | | | 69| 6.44k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ MYCAP(edge) -= thisflow; RESCAP(edge) += thisflow; ------------------ | | 572| 6.44k|#define RESCAP(i) (VECTOR(rescap)[(i)]) | | ------------------ | | | | 69| 6.44k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 956| 6.44k| for (idx = igraph_vector_int_size(&stack) - 2; 957| 34.7k| idx >= 0 && VECTOR(stack)[idx + 1] != nei; idx -= 2) { ------------------ | | 69| 34.7k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (957:30): [True: 34.7k, False: 0] | Branch (957:42): [True: 28.2k, False: 6.44k] ------------------ 958| 28.2k| igraph_integer_t e = VECTOR(stack)[idx]; ------------------ | | 69| 28.2k|#define VECTOR(v) ((v).stor_begin) ------------------ 959| 28.2k| if (e >= 0) { ------------------ | Branch (959:33): [True: 28.2k, False: 0] ------------------ 960| 28.2k| MYCAP(e) -= thisflow; ------------------ | | 907| 28.2k|#define MYCAP(i) (VECTOR(mycap)[(i)]) | | ------------------ | | | | 69| 28.2k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 961| 28.2k| RESCAP(e) += thisflow; ------------------ | | 572| 28.2k|#define RESCAP(i) (VECTOR(rescap)[(i)]) | | ------------------ | | | | 69| 28.2k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 962| 28.2k| } 963| 28.2k| } 964| 6.44k| CURRENT(actnode) += 1; ------------------ | | 571| 6.44k|#define CURRENT(i) (VECTOR(current)[(i)]) | | ------------------ | | | | 69| 6.44k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 965| 36.4k| } else if (edge < LAST(actnode)) { /* && VECTOR(added)[nei]==2 */ ------------------ | | 570| 36.4k|#define LAST(i) (VECTOR(first)[(i)+1]) | | ------------------ | | | | 69| 36.4k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (965:32): [True: 0, False: 36.4k] ------------------ 966| | /* The next edge leads to a vertex that was visited before, 967| | but it is currently not in 'stack' */ 968| 0| CURRENT(actnode) += 1; ------------------ | | 571| 0|#define CURRENT(i) (VECTOR(current)[(i)]) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 969| 36.4k| } else { 970| | /* Go backward, take out the node and the edge that leads to it */ 971| 36.4k| igraph_vector_int_pop_back(&stack); 972| 36.4k| igraph_vector_int_pop_back(&stack); 973| 36.4k| VECTOR(added)[actnode] = 2; ------------------ | | 69| 36.4k|#define VECTOR(v) ((v).stor_begin) ------------------ 974| 36.4k| } 975| 207k| } 976| | 977| | /* If non-empty, then it contains a path from source to target 978| | in the residual graph. We factor out this path from the flow. */ 979| 32.2k| if (!igraph_vector_int_empty(&stack)) { ------------------ | Branch (979:21): [True: 24.1k, False: 8.11k] ------------------ 980| 24.1k| igraph_integer_t pl = igraph_vector_int_size(&stack); 981| 24.1k| igraph_real_t thisflow = EXCESS(target); ------------------ | | 575| 24.1k|#define EXCESS(i) (VECTOR(excess)[(i)]) | | ------------------ | | | | 69| 24.1k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 982| 160k| for (i = 2; i < pl; i += 2) { ------------------ | Branch (982:33): [True: 136k, False: 24.1k] ------------------ 983| 136k| igraph_integer_t edge = VECTOR(stack)[i]; ------------------ | | 69| 136k|#define VECTOR(v) ((v).stor_begin) ------------------ 984| 136k| igraph_real_t rcap = MYCAP(edge); ------------------ | | 907| 136k|#define MYCAP(i) (VECTOR(mycap)[(i)]) | | ------------------ | | | | 69| 136k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 985| 136k| if (rcap < thisflow) { ------------------ | Branch (985:29): [True: 24.1k, False: 112k] ------------------ 986| 24.1k| thisflow = rcap; 987| 24.1k| } 988| 136k| } 989| 160k| for (i = 2; i < pl; i += 2) { ------------------ | Branch (989:33): [True: 136k, False: 24.1k] ------------------ 990| 136k| igraph_integer_t edge = VECTOR(stack)[i]; ------------------ | | 69| 136k|#define VECTOR(v) ((v).stor_begin) ------------------ 991| 136k| MYCAP(edge) -= thisflow; ------------------ | | 907| 136k|#define MYCAP(i) (VECTOR(mycap)[(i)]) | | ------------------ | | | | 69| 136k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 992| 136k| } 993| 24.1k| } 994| | 995| 32.2k| } while (!igraph_vector_int_empty(&stack)); ------------------ | Branch (995:22): [True: 24.1k, False: 8.11k] ------------------ 996| | 997| 8.11k| igraph_vector_destroy(&mycap); 998| 8.11k| igraph_vector_int_destroy(&added); 999| 8.11k| igraph_vector_int_destroy(&stack); 1000| 8.11k| IGRAPH_FINALLY_CLEAN(3); 1001| 8.11k| } 1002| | 1003| | /* ----------------------------------------------------------- */ 1004| | 1005| 14.3k| IGRAPH_CHECK(igraph_vector_resize(flow, no_of_orig_edges)); ------------------ | | 752| 14.3k| do { \ | | 753| 14.3k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 14.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 14.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 14.3k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 14.3k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1006| 1.01M| for (i = 0, j = 0; i < no_of_edges; i += 2, j++) { ------------------ | Branch (1006:28): [True: 997k, False: 14.3k] ------------------ 1007| 997k| igraph_integer_t pos = VECTOR(rank)[i]; ------------------ | | 69| 997k|#define VECTOR(v) ((v).stor_begin) ------------------ 1008| 997k| VECTOR(*flow)[j] = (capacity ? VECTOR(*capacity)[j] : 1.0) - ------------------ | | 69| 997k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*flow)[j] = (capacity ? VECTOR(*capacity)[j] : 1.0) - ------------------ | | 69| 997k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1008:33): [True: 997k, False: 0] ------------------ 1009| 997k| RESCAP(pos); ------------------ | | 572| 997k|#define RESCAP(i) (VECTOR(rescap)[(i)]) | | ------------------ | | | | 69| 997k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1010| 997k| } 1011| | 1012| 14.3k| igraph_vector_int_destroy(&rank); 1013| 14.3k| IGRAPH_FINALLY_CLEAN(1); 1014| 14.3k| } 1015| | 1016| 43.8k| igraph_dbuckets_destroy(&ibuckets); 1017| 43.8k| igraph_buckets_destroy(&buckets); 1018| 43.8k| igraph_vector_int_destroy(¤t); 1019| 43.8k| igraph_vector_int_destroy(&first); 1020| 43.8k| igraph_vector_int_destroy(&distance); 1021| 43.8k| igraph_vector_destroy(&excess); 1022| 43.8k| igraph_vector_destroy(&rescap); 1023| 43.8k| igraph_vector_int_destroy(&rev); 1024| 43.8k| igraph_vector_int_destroy(&to); 1025| 43.8k| igraph_dqueue_int_destroy(&bfsq); 1026| 43.8k| IGRAPH_FINALLY_CLEAN(10); 1027| | 1028| 43.8k| return IGRAPH_SUCCESS; 1029| 43.8k|} igraph_maxflow_value: 1089| 29.4k| igraph_maxflow_stats_t *stats) { 1090| | 1091| 29.4k| return igraph_maxflow(graph, value, /*flow=*/ NULL, /*cut=*/ NULL, 1092| | /*partition=*/ NULL, /*partition1=*/ NULL, 1093| 29.4k| source, target, capacity, stats); 1094| 29.4k|} igraph_vertex_connectivity: 2132| 1.15k| igraph_bool_t checks) { 2133| | 2134| 1.15k| igraph_bool_t ret = false; 2135| | 2136| 1.15k| if (checks) { ------------------ | Branch (2136:9): [True: 1.15k, False: 0] ------------------ 2137| 1.15k| IGRAPH_CHECK(igraph_i_connectivity_checks(graph, res, &ret)); ------------------ | | 752| 1.15k| do { \ | | 753| 1.15k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.15k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.15k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.15k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.15k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2138| 1.15k| } 2139| | 2140| | /* Are we done yet? */ 2141| 1.15k| if (!ret) { ------------------ | Branch (2141:9): [True: 837, False: 321] ------------------ 2142| 837| if (igraph_is_directed(graph)) { ------------------ | Branch (2142:13): [True: 0, False: 837] ------------------ 2143| 0| IGRAPH_CHECK(igraph_i_vertex_connectivity_directed(graph, res, /* all_edges_are_mutual = */ 0)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2144| 837| } else { 2145| 837| IGRAPH_CHECK(igraph_i_vertex_connectivity_undirected(graph, res)); ------------------ | | 752| 837| do { \ | | 753| 837| igraph_error_t igraph_i_ret = (expr); \ | | 754| 837| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 837] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 837| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2146| 837| } 2147| 837| } 2148| | 2149| 1.15k| return IGRAPH_SUCCESS; 2150| 1.15k|} flow.c:igraph_i_mf_bfs: 377| 45.7k| igraph_vector_t *rescap, igraph_vector_int_t *rev) { 378| | 379| 45.7k| igraph_integer_t k, l; 380| | 381| 45.7k| IGRAPH_UNUSED(source); ------------------ | | 12| 45.7k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 382| | 383| 45.7k| igraph_buckets_clear(buckets); 384| 45.7k| igraph_dbuckets_clear(ibuckets); 385| 45.7k| igraph_vector_int_fill(distance, no_of_nodes); 386| 45.7k| DIST(target) = 0; ------------------ | | 235| 45.7k|#define DIST(i) (VECTOR(*distance)[(i)]) | | ------------------ | | | | 69| 45.7k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 387| | 388| 45.7k| IGRAPH_CHECK(igraph_dqueue_int_push(bfsq, target)); ------------------ | | 752| 45.7k| do { \ | | 753| 45.7k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 45.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 45.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 45.7k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 45.7k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 389| 1.08M| while (!igraph_dqueue_int_empty(bfsq)) { ------------------ | Branch (389:12): [True: 1.03M, False: 45.7k] ------------------ 390| 1.03M| igraph_integer_t node = igraph_dqueue_int_pop(bfsq); 391| 1.03M| igraph_integer_t ndist = DIST(node) + 1; ------------------ | | 235| 1.03M|#define DIST(i) (VECTOR(*distance)[(i)]) | | ------------------ | | | | 69| 1.03M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 392| 6.60M| for (k = FIRST(node), l = LAST(node); k < l; k++) { ------------------ | | 228| 1.03M|#define FIRST(i) (VECTOR(*first)[(i)]) | | ------------------ | | | | 69| 1.03M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ for (k = FIRST(node), l = LAST(node); k < l; k++) { ------------------ | | 229| 1.03M|#define LAST(i) (VECTOR(*first)[(i)+1]) | | ------------------ | | | | 69| 1.03M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (392:47): [True: 5.56M, False: 1.03M] ------------------ 393| 5.56M| if (RESCAP(REV(k)) > 0) { ------------------ | | 231| 5.56M|#define RESCAP(i) (VECTOR(*rescap)[(i)]) | | ------------------ | | | | 69| 5.56M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (393:17): [True: 2.48M, False: 3.08M] ------------------ 394| 2.48M| igraph_integer_t nei = HEAD(k); ------------------ | | 233| 2.48M|#define HEAD(i) (VECTOR(*to)[(i)]) | | ------------------ | | | | 69| 2.48M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 395| 2.48M| if (DIST(nei) == no_of_nodes) { ------------------ | | 235| 2.48M|#define DIST(i) (VECTOR(*distance)[(i)]) | | ------------------ | | | | 69| 2.48M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (395:21): [True: 992k, False: 1.49M] ------------------ 396| 992k| DIST(nei) = ndist; ------------------ | | 235| 992k|#define DIST(i) (VECTOR(*distance)[(i)]) | | ------------------ | | | | 69| 992k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 397| 992k| CURRENT(nei) = FIRST(nei); ------------------ | | 230| 992k|#define CURRENT(i) (VECTOR(*current)[(i)]) | | ------------------ | | | | 69| 992k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ CURRENT(nei) = FIRST(nei); ------------------ | | 228| 992k|#define FIRST(i) (VECTOR(*first)[(i)]) | | ------------------ | | | | 69| 992k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 398| 992k| if (EXCESS(nei) > 0) { ------------------ | | 234| 992k|#define EXCESS(i) (VECTOR(*excess)[(i)]) | | ------------------ | | | | 69| 992k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (398:25): [True: 194k, False: 797k] ------------------ 399| 194k| igraph_buckets_add(buckets, ndist, nei); 400| 797k| } else { 401| 797k| igraph_dbuckets_add(ibuckets, ndist, nei); 402| 797k| } 403| 992k| IGRAPH_CHECK(igraph_dqueue_int_push(bfsq, nei)); ------------------ | | 752| 992k| do { \ | | 753| 992k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 992k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 992k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 992k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 992k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 404| 992k| } 405| 2.48M| } 406| 5.56M| } 407| 1.03M| } 408| | 409| 45.7k| return IGRAPH_SUCCESS; 410| 45.7k|} flow.c:igraph_i_mf_discharge: 336| 1.10M| igraph_integer_t *npushsince, igraph_integer_t *nrelabelsince) { 337| 1.34M| do { 338| 1.34M| igraph_integer_t i; 339| 1.34M| igraph_integer_t start = CURRENT(v); ------------------ | | 230| 1.34M|#define CURRENT(i) (VECTOR(*current)[(i)]) | | ------------------ | | | | 69| 1.34M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 340| 1.34M| igraph_integer_t stop = LAST(v); ------------------ | | 229| 1.34M|#define LAST(i) (VECTOR(*first)[(i)+1]) | | ------------------ | | | | 69| 1.34M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 341| 4.63M| for (i = start; i < stop; i++) { ------------------ | Branch (341:25): [True: 4.24M, False: 391k] ------------------ 342| 4.24M| if (RESCAP(i) > 0) { ------------------ | | 231| 4.24M|#define RESCAP(i) (VECTOR(*rescap)[(i)]) | | ------------------ | | | | 69| 4.24M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (342:17): [True: 3.04M, False: 1.20M] ------------------ 343| 3.04M| igraph_integer_t nei = HEAD(i); ------------------ | | 233| 3.04M|#define HEAD(i) (VECTOR(*to)[(i)]) | | ------------------ | | | | 69| 3.04M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 344| 3.04M| if (DIST(v) == DIST(nei) + 1) { ------------------ | | 235| 3.04M|#define DIST(i) (VECTOR(*distance)[(i)]) | | ------------------ | | | | 69| 3.04M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ if (DIST(v) == DIST(nei) + 1) { ------------------ | | 235| 3.04M|#define DIST(i) (VECTOR(*distance)[(i)]) | | ------------------ | | | | 69| 3.04M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (344:21): [True: 1.13M, False: 1.90M] ------------------ 345| 1.13M| PUSH((v), i, nei); ------------------ | | 242| 1.13M|#define PUSH(v,e,n) (igraph_i_mf_push((v), (e), (n), current, rescap, \ | | 243| 1.13M| excess, target, source, buckets, \ | | 244| 1.13M| ibuckets, distance, rev, stats, \ | | 245| 1.13M| npushsince)) ------------------ 346| 1.13M| if (EXCESS(v) == 0) { ------------------ | | 234| 1.13M|#define EXCESS(i) (VECTOR(*excess)[(i)]) | | ------------------ | | | | 69| 1.13M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (346:25): [True: 957k, False: 181k] ------------------ 347| 957k| break; 348| 957k| } 349| 1.13M| } 350| 3.04M| } 351| 4.24M| } 352| 1.34M| if (i == stop) { ------------------ | Branch (352:13): [True: 391k, False: 957k] ------------------ 353| 391k| igraph_integer_t origdist = DIST(v); ------------------ | | 235| 391k|#define DIST(i) (VECTOR(*distance)[(i)]) | | ------------------ | | | | 69| 391k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 354| 391k| RELABEL(v); ------------------ | | 246| 391k|#define RELABEL(v) (igraph_i_mf_relabel((v), no_of_nodes, distance, \ | | 247| 391k| first, rescap, to, current, \ | | 248| 391k| stats, nrelabelsince)) ------------------ 355| 391k| if (igraph_buckets_empty_bucket(buckets, origdist) && ------------------ | Branch (355:17): [True: 289k, False: 101k] ------------------ 356| 391k| igraph_dbuckets_empty_bucket(ibuckets, origdist)) { ------------------ | Branch (356:17): [True: 86.5k, False: 203k] ------------------ 357| 86.5k| GAP(origdist); ------------------ | | 249| 86.5k|#define GAP(b) (igraph_i_mf_gap((b), stats, buckets, ibuckets, \ | | 250| 86.5k| no_of_nodes, distance)) ------------------ 358| 86.5k| } 359| 391k| if (DIST(v) == no_of_nodes) { ------------------ | | 235| 391k|#define DIST(i) (VECTOR(*distance)[(i)]) | | ------------------ | | | | 69| 391k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (359:17): [True: 147k, False: 243k] ------------------ 360| 147k| break; 361| 147k| } 362| 957k| } else { 363| 957k| CURRENT(v) = i; ------------------ | | 230| 957k|#define CURRENT(i) (VECTOR(*current)[(i)]) | | ------------------ | | | | 69| 957k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 364| 957k| igraph_dbuckets_add(ibuckets, DIST(v), v); ------------------ | | 235| 957k|#define DIST(i) (VECTOR(*distance)[(i)]) | | ------------------ | | | | 69| 957k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 365| 957k| break; 366| 957k| } 367| 1.34M| } while (1); ------------------ | Branch (367:14): [Folded - Ignored] ------------------ 368| 1.10M|} flow.c:igraph_i_mf_push: 305| 1.13M| igraph_integer_t *npushsince) { 306| | 307| | 308| 1.13M| IGRAPH_UNUSED(current); ------------------ | | 12| 1.13M|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 309| 1.13M| IGRAPH_UNUSED(source); ------------------ | | 12| 1.13M|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 310| | 311| 1.13M| igraph_real_t delta = 312| 1.13M| RESCAP(e) < EXCESS(v) ? RESCAP(e) : EXCESS(v); ------------------ | | 231| 1.13M|#define RESCAP(i) (VECTOR(*rescap)[(i)]) | | ------------------ | | | | 69| 1.13M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ RESCAP(e) < EXCESS(v) ? RESCAP(e) : EXCESS(v); ------------------ | | 234| 1.13M|#define EXCESS(i) (VECTOR(*excess)[(i)]) | | ------------------ | | | | 69| 1.13M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ RESCAP(e) < EXCESS(v) ? RESCAP(e) : EXCESS(v); ------------------ | | 231| 181k|#define RESCAP(i) (VECTOR(*rescap)[(i)]) | | ------------------ | | | | 69| 181k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ RESCAP(e) < EXCESS(v) ? RESCAP(e) : EXCESS(v); ------------------ | | 234| 957k|#define EXCESS(i) (VECTOR(*excess)[(i)]) | | ------------------ | | | | 69| 957k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (312:9): [True: 181k, False: 957k] ------------------ 313| 1.13M| (stats->nopush)++; (*npushsince)++; 314| 1.13M| if (EXCESS(n) == 0 && n != target) { ------------------ | | 234| 1.13M|#define EXCESS(i) (VECTOR(*excess)[(i)]) | | ------------------ | | | | 69| 1.13M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (314:9): [True: 961k, False: 178k] | Branch (314:27): [True: 917k, False: 43.8k] ------------------ 315| 917k| igraph_dbuckets_delete(ibuckets, DIST(n), n); ------------------ | | 235| 917k|#define DIST(i) (VECTOR(*distance)[(i)]) | | ------------------ | | | | 69| 917k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 316| 917k| igraph_buckets_add(buckets, DIST(n), n); ------------------ | | 235| 917k|#define DIST(i) (VECTOR(*distance)[(i)]) | | ------------------ | | | | 69| 917k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 317| 917k| } 318| 1.13M| RESCAP(e) -= delta; ------------------ | | 231| 1.13M|#define RESCAP(i) (VECTOR(*rescap)[(i)]) | | ------------------ | | | | 69| 1.13M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 319| 1.13M| RESCAP(REV(e)) += delta; ------------------ | | 231| 1.13M|#define RESCAP(i) (VECTOR(*rescap)[(i)]) | | ------------------ | | | | 69| 1.13M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 320| 1.13M| EXCESS(n) += delta; ------------------ | | 234| 1.13M|#define EXCESS(i) (VECTOR(*excess)[(i)]) | | ------------------ | | | | 69| 1.13M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 321| 1.13M| EXCESS(v) -= delta; ------------------ | | 234| 1.13M|#define EXCESS(i) (VECTOR(*excess)[(i)]) | | ------------------ | | | | 69| 1.13M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 322| 1.13M|} flow.c:igraph_i_mf_relabel: 279| 391k| igraph_maxflow_stats_t *stats, igraph_integer_t *nrelabelsince) { 280| | 281| 391k| igraph_integer_t min = no_of_nodes; 282| 391k| igraph_integer_t k, l, min_edge = 0; 283| 391k| (stats->norelabel)++; (*nrelabelsince)++; 284| 391k| DIST(v) = no_of_nodes; ------------------ | | 235| 391k|#define DIST(i) (VECTOR(*distance)[(i)]) | | ------------------ | | | | 69| 391k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 285| 2.94M| for (k = FIRST(v), l = LAST(v); k < l; k++) { ------------------ | | 228| 391k|#define FIRST(i) (VECTOR(*first)[(i)]) | | ------------------ | | | | 69| 391k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ for (k = FIRST(v), l = LAST(v); k < l; k++) { ------------------ | | 229| 391k|#define LAST(i) (VECTOR(*first)[(i)+1]) | | ------------------ | | | | 69| 391k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (285:37): [True: 2.54M, False: 391k] ------------------ 286| 2.54M| if (RESCAP(k) > 0 && DIST(HEAD(k)) < min) { ------------------ | | 231| 2.54M|#define RESCAP(i) (VECTOR(*rescap)[(i)]) | | ------------------ | | | | 69| 2.54M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ if (RESCAP(k) > 0 && DIST(HEAD(k)) < min) { ------------------ | | 235| 1.15M|#define DIST(i) (VECTOR(*distance)[(i)]) | | ------------------ | | | | 69| 1.15M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (286:13): [True: 1.15M, False: 1.39M] | Branch (286:30): [True: 249k, False: 910k] ------------------ 287| 249k| min = DIST(HEAD(k)); ------------------ | | 235| 249k|#define DIST(i) (VECTOR(*distance)[(i)]) | | ------------------ | | | | 69| 249k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 288| 249k| min_edge = k; 289| 249k| } 290| 2.54M| } 291| 391k| min++; 292| 391k| if (min < no_of_nodes) { ------------------ | Branch (292:9): [True: 243k, False: 147k] ------------------ 293| 243k| DIST(v) = min; ------------------ | | 235| 243k|#define DIST(i) (VECTOR(*distance)[(i)]) | | ------------------ | | | | 69| 243k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 294| 243k| CURRENT(v) = min_edge; ------------------ | | 230| 243k|#define CURRENT(i) (VECTOR(*current)[(i)]) | | ------------------ | | | | 69| 243k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 295| 243k| } 296| 391k|} flow.c:igraph_i_mf_gap: 259| 86.5k| igraph_vector_int_t *distance) { 260| | 261| 86.5k| IGRAPH_UNUSED(buckets); ------------------ | | 12| 86.5k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 262| | 263| 86.5k| igraph_integer_t bo; 264| 86.5k| (stats->nogap)++; 265| 1.77M| for (bo = b + 1; bo <= no_of_nodes; bo++) { ------------------ | Branch (265:22): [True: 1.68M, False: 86.5k] ------------------ 266| 1.84M| while (!igraph_dbuckets_empty_bucket(ibuckets, bo)) { ------------------ | Branch (266:16): [True: 153k, False: 1.68M] ------------------ 267| 153k| igraph_integer_t n = igraph_dbuckets_pop(ibuckets, bo); 268| 153k| (stats->nogapnodes)++; 269| 153k| DIST(n) = no_of_nodes; ------------------ | | 235| 153k|#define DIST(i) (VECTOR(*distance)[(i)]) | | ------------------ | | | | 69| 153k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 270| 153k| } 271| 1.68M| } 272| 86.5k|} flow.c:igraph_i_st_vertex_connectivity_check_errors: 1733| 41.4k| igraph_integer_t *no_conn) { 1734| 41.4k| igraph_integer_t no_of_nodes = igraph_vcount(graph); 1735| 41.4k| igraph_integer_t eid; 1736| 41.4k| igraph_bool_t conn; 1737| 41.4k| *done = 1; 1738| 41.4k| *no_conn = 0; 1739| | 1740| 41.4k| if (source == target) { ------------------ | Branch (1740:9): [True: 0, False: 41.4k] ------------------ 1741| 0| IGRAPH_ERROR("Source and target vertices are the same.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1742| 0| } 1743| | 1744| 41.4k| if (source < 0 || source >= no_of_nodes || target < 0 || target >= no_of_nodes) { ------------------ | Branch (1744:9): [True: 0, False: 41.4k] | Branch (1744:23): [True: 0, False: 41.4k] | Branch (1744:48): [True: 0, False: 41.4k] | Branch (1744:62): [True: 0, False: 41.4k] ------------------ 1745| 0| IGRAPH_ERROR("Invalid source or target vertex.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1746| 0| } 1747| | 1748| 41.4k| switch (neighbors) { 1749| 0| case IGRAPH_VCONN_NEI_ERROR: ------------------ | Branch (1749:5): [True: 0, False: 41.4k] ------------------ 1750| 0| IGRAPH_CHECK(igraph_are_connected(graph, source, target, &conn)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1751| 0| if (conn) { ------------------ | Branch (1751:13): [True: 0, False: 0] ------------------ 1752| 0| IGRAPH_ERROR("Source and target vertices connected.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1753| 0| } 1754| 0| break; 1755| 0| case IGRAPH_VCONN_NEI_NEGATIVE: ------------------ | Branch (1755:5): [True: 0, False: 41.4k] ------------------ 1756| 0| IGRAPH_CHECK(igraph_are_connected(graph, source, target, &conn)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1757| 0| if (conn) { ------------------ | Branch (1757:13): [True: 0, False: 0] ------------------ 1758| 0| *res = -1; 1759| 0| return IGRAPH_SUCCESS; 1760| 0| } 1761| 0| break; 1762| 41.4k| case IGRAPH_VCONN_NEI_NUMBER_OF_NODES: ------------------ | Branch (1762:5): [True: 41.4k, False: 0] ------------------ 1763| 41.4k| IGRAPH_CHECK(igraph_are_connected(graph, source, target, &conn)); ------------------ | | 752| 41.4k| do { \ | | 753| 41.4k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 41.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 41.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 41.4k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 41.4k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1764| 41.4k| if (conn) { ------------------ | Branch (1764:13): [True: 11.9k, False: 29.4k] ------------------ 1765| 11.9k| *res = no_of_nodes; 1766| 11.9k| return IGRAPH_SUCCESS; 1767| 11.9k| } 1768| 29.4k| break; 1769| 29.4k| case IGRAPH_VCONN_NEI_IGNORE: ------------------ | Branch (1769:5): [True: 0, False: 41.4k] ------------------ 1770| 0| IGRAPH_CHECK(igraph_get_eid(graph, &eid, source, target, IGRAPH_DIRECTED, /*error=*/ false)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1771| 0| if (eid >= 0) { ------------------ | Branch (1771:13): [True: 0, False: 0] ------------------ 1772| 0| IGRAPH_CHECK(igraph_count_multiple_1(graph, no_conn, eid)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1773| 0| } 1774| 0| break; 1775| 0| default: ------------------ | Branch (1775:5): [True: 0, False: 41.4k] ------------------ 1776| 0| IGRAPH_ERROR("Unknown `igraph_vconn_nei_t'.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1777| 0| break; 1778| 41.4k| } 1779| 29.4k| *done = 0; 1780| 29.4k| return IGRAPH_SUCCESS; 1781| 41.4k|} flow.c:igraph_i_connectivity_checks: 2054| 1.15k| igraph_bool_t *found) { 2055| 1.15k| igraph_bool_t conn; 2056| 1.15k| *found = 0; 2057| | 2058| 1.15k| if (igraph_vcount(graph) == 0) { ------------------ | Branch (2058:9): [True: 0, False: 1.15k] ------------------ 2059| 0| *res = 0; 2060| 0| *found = 1; 2061| 0| return IGRAPH_SUCCESS; 2062| 0| } 2063| | 2064| 1.15k| IGRAPH_CHECK(igraph_is_connected(graph, &conn, IGRAPH_STRONG)); ------------------ | | 752| 1.15k| do { \ | | 753| 1.15k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.15k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.15k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.15k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.15k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2065| 1.15k| if (!conn) { ------------------ | Branch (2065:9): [True: 229, False: 929] ------------------ 2066| 229| *res = 0; 2067| 229| *found = 1; 2068| 929| } else { 2069| 929| igraph_vector_int_t degree; 2070| 929| IGRAPH_VECTOR_INT_INIT_FINALLY(°ree, 0); ------------------ | | 124| 929| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 929| do { \ | | | | 753| 929| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 929| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 929| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 929] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 929| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 929| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 929| do { \ | | | | 696| 929| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 929| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 929| * incorrect destructor function with the pointer */ \ | | | | 699| 929| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 929| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 929| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 2071| 929| if (!igraph_is_directed(graph)) { ------------------ | Branch (2071:13): [True: 929, False: 0] ------------------ 2072| 929| IGRAPH_CHECK(igraph_degree(graph, °ree, igraph_vss_all(), ------------------ | | 752| 929| do { \ | | 753| 929| igraph_error_t igraph_i_ret = (expr); \ | | 754| 929| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 929| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 929] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 929| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2073| 929| IGRAPH_OUT, IGRAPH_LOOPS)); 2074| 929| if (igraph_vector_int_min(°ree) == 1) { ------------------ | Branch (2074:17): [True: 92, False: 837] ------------------ 2075| 92| *res = 1; 2076| 92| *found = 1; 2077| 92| } 2078| 929| } else { 2079| | /* directed, check both in- & out-degree */ 2080| 0| IGRAPH_CHECK(igraph_degree(graph, °ree, igraph_vss_all(), ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2081| 0| IGRAPH_OUT, IGRAPH_LOOPS)); 2082| 0| if (igraph_vector_int_min(°ree) == 1) { ------------------ | Branch (2082:17): [True: 0, False: 0] ------------------ 2083| 0| *res = 1; 2084| 0| *found = 1; 2085| 0| } else { 2086| 0| IGRAPH_CHECK(igraph_degree(graph, °ree, igraph_vss_all(), ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2087| 0| IGRAPH_IN, IGRAPH_LOOPS)); 2088| 0| if (igraph_vector_int_min(°ree) == 1) { ------------------ | Branch (2088:21): [True: 0, False: 0] ------------------ 2089| 0| *res = 1; 2090| 0| *found = 1; 2091| 0| } 2092| 0| } 2093| 0| } 2094| 929| igraph_vector_int_destroy(°ree); 2095| 929| IGRAPH_FINALLY_CLEAN(1); 2096| 929| } 2097| 1.15k| return IGRAPH_SUCCESS; 2098| 1.15k|} flow.c:igraph_i_vertex_connectivity_directed: 1930| 837|) { 1931| 837| igraph_integer_t no_of_nodes = igraph_vcount(graph); 1932| 837| igraph_integer_t no_of_edges; 1933| 837| igraph_integer_t i, j, k, len; 1934| 837| igraph_integer_t minconn = no_of_nodes - 1, conn = 0; 1935| 837| igraph_t split_graph; 1936| 837| igraph_vector_t capacity; 1937| 837| igraph_bool_t done; 1938| 837| igraph_integer_t dummy_num_connections; 1939| 837| igraph_vector_int_t incs; 1940| 837| igraph_real_t real_res; 1941| | 1942| | /* Create the new graph */ 1943| 837| IGRAPH_CHECK(igraph_i_split_vertices(graph, &split_graph)); ------------------ | | 752| 837| do { \ | | 753| 837| igraph_error_t igraph_i_ret = (expr); \ | | 754| 837| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 837] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 837| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1944| 837| IGRAPH_FINALLY(igraph_destroy, &split_graph); ------------------ | | 695| 837| do { \ | | 696| 837| /* the following branch makes the compiler check the compatibility of \ | | 697| 837| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 837| * incorrect destructor function with the pointer */ \ | | 699| 837| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 837| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 837| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 1945| | 1946| | /* Create the capacity vector, fill it with ones */ 1947| 837| no_of_edges = igraph_ecount(&split_graph); 1948| 837| IGRAPH_VECTOR_INIT_FINALLY(&capacity, no_of_edges); ------------------ | | 109| 837| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \ | | ------------------ | | | | 752| 837| do { \ | | | | 753| 837| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 837| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 837] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 837| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 110| 837| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0) | | ------------------ | | | | 695| 837| do { \ | | | | 696| 837| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 837| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 837| * incorrect destructor function with the pointer */ \ | | | | 699| 837| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 837| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 837| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (110:60): [Folded - Ignored] | | ------------------ ------------------ 1949| 837| igraph_vector_fill(&capacity, 1); 1950| | 1951| 837| IGRAPH_VECTOR_INT_INIT_FINALLY(&incs, 0); ------------------ | | 124| 837| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 837| do { \ | | | | 753| 837| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 837| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 837] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 837| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 837| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 837| do { \ | | | | 696| 837| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 837| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 837| * incorrect destructor function with the pointer */ \ | | | | 699| 837| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 837| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 837| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 1952| | 1953| 8.72k| for (i = 0; i < no_of_nodes; i++) { ------------------ | Branch (1953:17): [True: 7.89k, False: 829] ------------------ 1954| 49.3k| for (j = all_edges_are_mutual ? i + 1 : 0; j < no_of_nodes; j++) { ------------------ | Branch (1954:18): [True: 7.89k, False: 0] | Branch (1954:52): [True: 41.4k, False: 7.89k] ------------------ 1955| 41.4k| if (i == j) { ------------------ | Branch (1955:17): [True: 0, False: 41.4k] ------------------ 1956| 0| continue; 1957| 0| } 1958| | 1959| 41.4k| IGRAPH_ALLOW_INTERRUPTION(); ------------------ | | 47| 41.4k| do { \ | | 48| 41.4k| if (igraph_i_interruption_handler) { \ | | ------------------ | | | Branch (48:13): [True: 0, False: 41.4k] | | ------------------ | | 49| 0| if (igraph_allow_interruption(NULL) != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (49:17): [True: 0, False: 0] | | ------------------ | | 50| 0| return IGRAPH_INTERRUPTED; \ | | 51| 0| } \ | | 52| 0| } \ | | 53| 41.4k| } while (0) | | ------------------ | | | Branch (53:14): [Folded - Ignored] | | ------------------ ------------------ 1960| | 1961| | /* Check for easy cases */ 1962| 41.4k| IGRAPH_CHECK(igraph_i_st_vertex_connectivity_check_errors( ------------------ | | 752| 41.4k| do { \ | | 753| 41.4k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 41.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 41.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 41.4k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 41.4k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1963| 41.4k| graph, &conn, i, j, IGRAPH_VCONN_NEI_NUMBER_OF_NODES, &done, 1964| 41.4k| &dummy_num_connections 1965| 41.4k| )); 1966| | 1967| | /* 'done' will be set to true if the two vertices are already 1968| | * connected, and in this case 'res' will be set to the number of 1969| | * nodes-1. 1970| | * 1971| | * Also, since we used IGRAPH_VCONN_NEI_NUMBER_OF_NODES, 1972| | * dummy_num_connections will always be zero, no need to deal with 1973| | * it */ 1974| 41.4k| IGRAPH_ASSERT(dummy_num_connections == 0); ------------------ | | 1107| 41.4k| do { \ | | 1108| 41.4k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 41.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 41.4k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 41.4k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 1975| | 1976| 41.4k| if (!done) { ------------------ | Branch (1976:17): [True: 29.4k, False: 11.9k] ------------------ 1977| | /* "Disable" the edges incident on the input half of the source vertex 1978| | * and the output half of the target vertex */ 1979| 29.4k| IGRAPH_CHECK(igraph_incident(&split_graph, &incs, i + no_of_nodes, IGRAPH_ALL)); ------------------ | | 752| 29.4k| do { \ | | 753| 29.4k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 29.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 29.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 29.4k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 29.4k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1980| 29.4k| len = igraph_vector_int_size(&incs); 1981| 179k| for (k = 0; k < len; k++) { ------------------ | Branch (1981:29): [True: 150k, False: 29.4k] ------------------ 1982| 150k| VECTOR(capacity)[VECTOR(incs)[k]] = 0; ------------------ | | 69| 150k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(capacity)[VECTOR(incs)[k]] = 0; ------------------ | | 69| 150k|#define VECTOR(v) ((v).stor_begin) ------------------ 1983| 150k| } 1984| 29.4k| IGRAPH_CHECK(igraph_incident(&split_graph, &incs, j, IGRAPH_ALL)); ------------------ | | 752| 29.4k| do { \ | | 753| 29.4k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 29.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 29.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 29.4k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 29.4k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1985| 29.4k| len = igraph_vector_int_size(&incs); 1986| 167k| for (k = 0; k < len; k++) { ------------------ | Branch (1986:29): [True: 138k, False: 29.4k] ------------------ 1987| 138k| VECTOR(capacity)[VECTOR(incs)[k]] = 0; ------------------ | | 69| 138k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(capacity)[VECTOR(incs)[k]] = 0; ------------------ | | 69| 138k|#define VECTOR(v) ((v).stor_begin) ------------------ 1988| 138k| } 1989| | 1990| | /* Do the maximum flow */ 1991| 29.4k| IGRAPH_CHECK(igraph_maxflow_value( ------------------ | | 752| 29.4k| do { \ | | 753| 29.4k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 29.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 29.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 29.4k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 29.4k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1992| 29.4k| &split_graph, &real_res, i, j + no_of_nodes, &capacity, 0 1993| 29.4k| )); 1994| | 1995| | /* Restore the capacities */ 1996| 29.4k| IGRAPH_CHECK(igraph_incident(&split_graph, &incs, i + no_of_nodes, IGRAPH_ALL)); ------------------ | | 752| 29.4k| do { \ | | 753| 29.4k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 29.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 29.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 29.4k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 29.4k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1997| 29.4k| len = igraph_vector_int_size(&incs); 1998| 179k| for (k = 0; k < len; k++) { ------------------ | Branch (1998:29): [True: 150k, False: 29.4k] ------------------ 1999| 150k| VECTOR(capacity)[VECTOR(incs)[k]] = 1; ------------------ | | 69| 150k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(capacity)[VECTOR(incs)[k]] = 1; ------------------ | | 69| 150k|#define VECTOR(v) ((v).stor_begin) ------------------ 2000| 150k| } 2001| 29.4k| IGRAPH_CHECK(igraph_incident(&split_graph, &incs, j, IGRAPH_ALL)); ------------------ | | 752| 29.4k| do { \ | | 753| 29.4k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 29.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 29.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 29.4k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 29.4k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2002| 29.4k| len = igraph_vector_int_size(&incs); 2003| 167k| for (k = 0; k < len; k++) { ------------------ | Branch (2003:29): [True: 138k, False: 29.4k] ------------------ 2004| 138k| VECTOR(capacity)[VECTOR(incs)[k]] = 1; ------------------ | | 69| 138k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(capacity)[VECTOR(incs)[k]] = 1; ------------------ | | 69| 138k|#define VECTOR(v) ((v).stor_begin) ------------------ 2005| 138k| } 2006| | 2007| 29.4k| conn = (igraph_integer_t) real_res; 2008| 29.4k| } 2009| | 2010| 41.4k| if (conn < minconn) { ------------------ | Branch (2010:17): [True: 931, False: 40.5k] ------------------ 2011| 931| minconn = conn; 2012| 931| if (conn == 0) { ------------------ | Branch (2012:21): [True: 0, False: 931] ------------------ 2013| 0| break; 2014| 0| } 2015| 931| } 2016| 41.4k| } 2017| | 2018| 7.89k| if (minconn == 0) { ------------------ | Branch (2018:13): [True: 8, False: 7.89k] ------------------ 2019| 8| break; 2020| 8| } 2021| 7.89k| } 2022| | 2023| 837| if (res) { ------------------ | Branch (2023:9): [True: 837, False: 0] ------------------ 2024| 837| *res = minconn; 2025| 837| } 2026| | 2027| 837| igraph_vector_int_destroy(&incs); 2028| 837| igraph_vector_destroy(&capacity); 2029| 837| igraph_destroy(&split_graph); 2030| 837| IGRAPH_FINALLY_CLEAN(3); 2031| | 2032| 837| return IGRAPH_SUCCESS; 2033| 837|} flow.c:igraph_i_vertex_connectivity_undirected: 2036| 837| igraph_integer_t *res) { 2037| 837| igraph_t newgraph; 2038| | 2039| 837| IGRAPH_CHECK(igraph_copy(&newgraph, graph)); ------------------ | | 752| 837| do { \ | | 753| 837| igraph_error_t igraph_i_ret = (expr); \ | | 754| 837| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 837] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 837| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2040| 837| IGRAPH_FINALLY(igraph_destroy, &newgraph); ------------------ | | 695| 837| do { \ | | 696| 837| /* the following branch makes the compiler check the compatibility of \ | | 697| 837| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 837| * incorrect destructor function with the pointer */ \ | | 699| 837| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 837| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 837| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 2041| 837| IGRAPH_CHECK(igraph_to_directed(&newgraph, IGRAPH_TO_DIRECTED_MUTUAL)); ------------------ | | 752| 837| do { \ | | 753| 837| igraph_error_t igraph_i_ret = (expr); \ | | 754| 837| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 837] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 837| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2042| | 2043| 837| IGRAPH_CHECK(igraph_i_vertex_connectivity_directed(&newgraph, res, /* all_edges_are_mutual = */ 1)); ------------------ | | 752| 837| do { \ | | 753| 837| igraph_error_t igraph_i_ret = (expr); \ | | 754| 837| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 837] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 837| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2044| | 2045| 837| igraph_destroy(&newgraph); 2046| 837| IGRAPH_FINALLY_CLEAN(1); 2047| | 2048| 837| return IGRAPH_SUCCESS; 2049| 837|} igraph_i_split_vertices: 62| 837|igraph_error_t igraph_i_split_vertices(const igraph_t* graph, igraph_t* result) { 63| 837| igraph_integer_t no_of_nodes = igraph_vcount(graph); 64| 837| igraph_integer_t no_of_edges = igraph_ecount(graph); 65| 837| igraph_integer_t i; 66| 837| igraph_vector_int_t edges; 67| | 68| 837| if (!igraph_is_directed(graph)) { ------------------ | Branch (68:9): [True: 0, False: 837] ------------------ 69| 0| IGRAPH_ERROR("Input graph must be directed.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 70| 0| } 71| | 72| 837| IGRAPH_VECTOR_INT_INIT_FINALLY(&edges, 0); ------------------ | | 124| 837| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 837| do { \ | | | | 753| 837| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 837| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 837] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 837| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 837| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 837| do { \ | | | | 696| 837| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 837| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 837| * incorrect destructor function with the pointer */ \ | | | | 699| 837| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 837| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 837| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 73| 837| IGRAPH_CHECK(igraph_vector_int_reserve(&edges, 2 * (no_of_edges + no_of_nodes))); ------------------ | | 752| 837| do { \ | | 753| 837| igraph_error_t igraph_i_ret = (expr); \ | | 754| 837| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 837] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 837| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 74| 837| IGRAPH_CHECK(igraph_get_edgelist(graph, &edges, 0)); ------------------ | | 752| 837| do { \ | | 753| 837| igraph_error_t igraph_i_ret = (expr); \ | | 754| 837| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 837] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 837| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 75| 837| IGRAPH_CHECK(igraph_vector_int_resize(&edges, 2 * (no_of_edges + no_of_nodes))); ------------------ | | 752| 837| do { \ | | 753| 837| igraph_error_t igraph_i_ret = (expr); \ | | 754| 837| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 837] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 837| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 76| | 77| 36.8k| for (i = 0; i < 2 * no_of_edges; i += 2) { ------------------ | Branch (77:17): [True: 35.9k, False: 837] ------------------ 78| 35.9k| igraph_integer_t to = VECTOR(edges)[i + 1]; ------------------ | | 69| 35.9k|#define VECTOR(v) ((v).stor_begin) ------------------ 79| 35.9k| VECTOR(edges)[i + 1] = no_of_nodes + to; ------------------ | | 69| 35.9k|#define VECTOR(v) ((v).stor_begin) ------------------ 80| 35.9k| } 81| | 82| 8.73k| for (i = 0; i < no_of_nodes; i++) { ------------------ | Branch (82:17): [True: 7.89k, False: 837] ------------------ 83| 7.89k| VECTOR(edges)[2 * (no_of_edges + i)] = no_of_nodes + i; ------------------ | | 69| 7.89k|#define VECTOR(v) ((v).stor_begin) ------------------ 84| 7.89k| VECTOR(edges)[2 * (no_of_edges + i) + 1] = i; ------------------ | | 69| 7.89k|#define VECTOR(v) ((v).stor_begin) ------------------ 85| 7.89k| } 86| | 87| 837| IGRAPH_CHECK(igraph_create(result, &edges, 2 * no_of_nodes, IGRAPH_DIRECTED)); ------------------ | | 752| 837| do { \ | | 753| 837| igraph_error_t igraph_i_ret = (expr); \ | | 754| 837| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 837] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 837| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 88| | 89| 837| igraph_vector_int_destroy(&edges); 90| 837| IGRAPH_FINALLY_CLEAN(1); 91| | 92| 837| return IGRAPH_SUCCESS; 93| 837|} igraph_even_tarjan_reduction: 87| 709| igraph_vector_t *capacity) { 88| | 89| 709| igraph_integer_t no_of_nodes = igraph_vcount(graph); 90| 709| igraph_integer_t no_of_edges = igraph_ecount(graph); 91| | 92| 709| igraph_integer_t new_no_of_nodes; 93| 709| igraph_integer_t new_no_of_edges = no_of_edges * 2; 94| | 95| 709| igraph_vector_int_t edges; 96| 709| igraph_integer_t edgeptr = 0, capptr = 0; 97| 709| igraph_integer_t i; 98| | 99| 709| IGRAPH_SAFE_MULT(no_of_nodes, 2, &new_no_of_nodes); ------------------ | | 57| 709| do { \ | | 58| 709| igraph_integer_t _safe_a = (a), _safe_b = (b); \ | | 59| 709| igraph_integer_t _safe_prod; \ | | 60| 709| if (__builtin_mul_overflow(_safe_a, _safe_b, &_safe_prod)) { \ | | ------------------ | | | Branch (60:13): [True: 0, False: 709] | | ------------------ | | 61| 0| IGRAPH_ERRORF("Overflow when multiplying %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \ | | ------------------ | | | | 550| 0| do { \ | | | | 551| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | | | 552| 0| igraph_errno, __VA_ARGS__) ; \ | | | | 553| 0| return igraph_errno; \ | | | | 554| 0| } while (0) | | | | ------------------ | | | | | Branch (554:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 62| 0| } \ | | 63| 709| *(res) = _safe_prod; \ | | 64| 709| } while (0) | | ------------------ | | | Branch (64:14): [Folded - Ignored] | | ------------------ ------------------ 100| 709| IGRAPH_SAFE_ADD(new_no_of_edges, no_of_nodes, &new_no_of_edges); ------------------ | | 47| 709| do { \ | | 48| 709| igraph_integer_t _safe_a = (a), _safe_b = (b); \ | | 49| 709| igraph_integer_t _safe_sum; \ | | 50| 709| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 709] | | ------------------ | | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \ | | ------------------ | | | | 550| 0| do { \ | | | | 551| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | | | 552| 0| igraph_errno, __VA_ARGS__) ; \ | | | | 553| 0| return igraph_errno; \ | | | | 554| 0| } while (0) | | | | ------------------ | | | | | Branch (554:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 52| 0| } \ | | 53| 709| *(res) = _safe_sum; \ | | 54| 709| } while (0) | | ------------------ | | | Branch (54:14): [Folded - Ignored] | | ------------------ ------------------ 101| | 102| | /* To ensure the size of the edges vector will not overflow. */ 103| 709| if (new_no_of_edges > IGRAPH_ECOUNT_MAX) { ------------------ | | 122| 709|#define IGRAPH_ECOUNT_MAX (IGRAPH_INTEGER_MAX/2) | | ------------------ | | | | 78| 709|# define IGRAPH_INTEGER_MAX INT64_MAX | | ------------------ ------------------ | Branch (103:9): [True: 0, False: 709] ------------------ 104| 0| IGRAPH_ERROR("Overflow in number of edges.", IGRAPH_EOVERFLOW); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 105| 0| } 106| | 107| 709| IGRAPH_VECTOR_INT_INIT_FINALLY(&edges, new_no_of_edges * 2); ------------------ | | 124| 709| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 709| do { \ | | | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 709] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 709| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 709| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 709| do { \ | | | | 696| 709| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 709| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 709| * incorrect destructor function with the pointer */ \ | | | | 699| 709| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 709| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 709| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 108| | 109| 709| if (capacity) { ------------------ | Branch (109:9): [True: 709, False: 0] ------------------ 110| 709| IGRAPH_CHECK(igraph_vector_resize(capacity, new_no_of_edges)); ------------------ | | 752| 709| do { \ | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 709] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 709| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 111| 709| } 112| | 113| | /* Every vertex 'i' is replaced by two vertices, i' and i'' */ 114| | /* id[i'] := id[i] ; id[i''] := id[i] + no_of_nodes */ 115| | 116| | /* One edge for each original vertex, for i, we add (i',i'') */ 117| 7.90k| for (i = 0; i < no_of_nodes; i++) { ------------------ | Branch (117:17): [True: 7.19k, False: 709] ------------------ 118| 7.19k| VECTOR(edges)[edgeptr++] = i; ------------------ | | 69| 7.19k|#define VECTOR(v) ((v).stor_begin) ------------------ 119| 7.19k| VECTOR(edges)[edgeptr++] = i + no_of_nodes; ------------------ | | 69| 7.19k|#define VECTOR(v) ((v).stor_begin) ------------------ 120| 7.19k| if (capacity) { ------------------ | Branch (120:13): [True: 7.19k, False: 0] ------------------ 121| 7.19k| VECTOR(*capacity)[capptr++] = 1.0; ------------------ | | 69| 7.19k|#define VECTOR(v) ((v).stor_begin) ------------------ 122| 7.19k| } 123| 7.19k| } 124| | 125| | /* Two news edges for each original edge 126| | (from,to) becomes (from'',to'), (to'',from') */ 127| 11.7k| for (i = 0; i < no_of_edges; i++) { ------------------ | Branch (127:17): [True: 11.0k, False: 709] ------------------ 128| 11.0k| igraph_integer_t from = IGRAPH_FROM(graph, i); ------------------ | | 103| 11.0k|#define IGRAPH_FROM(graph,eid) ((igraph_integer_t)(VECTOR((graph)->from)[(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 11.0k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 129| 11.0k| igraph_integer_t to = IGRAPH_TO(graph, i); ------------------ | | 116| 11.0k|#define IGRAPH_TO(graph,eid) ((igraph_integer_t)(VECTOR((graph)->to) [(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 11.0k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 130| 11.0k| VECTOR(edges)[edgeptr++] = from + no_of_nodes; ------------------ | | 69| 11.0k|#define VECTOR(v) ((v).stor_begin) ------------------ 131| 11.0k| VECTOR(edges)[edgeptr++] = to; ------------------ | | 69| 11.0k|#define VECTOR(v) ((v).stor_begin) ------------------ 132| 11.0k| VECTOR(edges)[edgeptr++] = to + no_of_nodes; ------------------ | | 69| 11.0k|#define VECTOR(v) ((v).stor_begin) ------------------ 133| 11.0k| VECTOR(edges)[edgeptr++] = from; ------------------ | | 69| 11.0k|#define VECTOR(v) ((v).stor_begin) ------------------ 134| 11.0k| if (capacity) { ------------------ | Branch (134:13): [True: 11.0k, False: 0] ------------------ 135| 11.0k| VECTOR(*capacity)[capptr++] = no_of_nodes; /* TODO: should be Inf */ ------------------ | | 69| 11.0k|#define VECTOR(v) ((v).stor_begin) ------------------ 136| 11.0k| VECTOR(*capacity)[capptr++] = no_of_nodes; /* TODO: should be Inf */ ------------------ | | 69| 11.0k|#define VECTOR(v) ((v).stor_begin) ------------------ 137| 11.0k| } 138| 11.0k| } 139| | 140| 709| IGRAPH_CHECK(igraph_create(graphbar, &edges, new_no_of_nodes, ------------------ | | 752| 709| do { \ | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 709] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 709| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 141| 709| IGRAPH_DIRECTED)); 142| | 143| 709| igraph_vector_int_destroy(&edges); 144| 709| IGRAPH_FINALLY_CLEAN(1); 145| | 146| 709| return IGRAPH_SUCCESS; 147| 709|} igraph_reverse_residual_graph: 264| 5.36k| const igraph_vector_t *flow) { 265| 5.36k| igraph_vector_int_t tmp; 266| 5.36k| igraph_integer_t no_of_edges = igraph_ecount(graph); 267| | 268| 5.36k| if (capacity && igraph_vector_size(capacity) != no_of_edges) { ------------------ | Branch (268:9): [True: 5.36k, False: 0] | Branch (268:21): [True: 0, False: 5.36k] ------------------ 269| 0| IGRAPH_ERROR("Invalid `capacity' vector size", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 270| 0| } 271| 5.36k| if (igraph_vector_size(flow) != no_of_edges) { ------------------ | Branch (271:9): [True: 0, False: 5.36k] ------------------ 272| 0| IGRAPH_ERROR("Invalid `flow' vector size", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 273| 0| } 274| 5.36k| IGRAPH_VECTOR_INT_INIT_FINALLY(&tmp, 0); ------------------ | | 124| 5.36k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 5.36k| do { \ | | | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 5.36k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 5.36k| do { \ | | | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | | | 699| 5.36k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 275| | 276| 5.36k| IGRAPH_CHECK(igraph_i_reverse_residual_graph(graph, capacity, residual, ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 277| 5.36k| flow, &tmp)); 278| | 279| 5.36k| igraph_vector_int_destroy(&tmp); 280| 5.36k| IGRAPH_FINALLY_CLEAN(1); 281| | 282| 5.36k| return IGRAPH_SUCCESS; 283| 5.36k|} igraph_all_st_mincuts: 1361| 5.36k| const igraph_vector_t *capacity) { 1362| | 1363| 5.36k| igraph_integer_t no_of_nodes = igraph_vcount(graph); 1364| 5.36k| igraph_integer_t no_of_edges = igraph_ecount(graph); 1365| 5.36k| igraph_vector_t flow; 1366| 5.36k| igraph_t residual; 1367| 5.36k| igraph_vector_int_t NtoL; 1368| 5.36k| igraph_vector_int_t cut; 1369| 5.36k| igraph_integer_t newsource, newtarget; 1370| 5.36k| igraph_marked_queue_int_t S; 1371| 5.36k| igraph_estack_t T; 1372| 5.36k| igraph_i_all_st_mincuts_data_t pivot_data; 1373| 5.36k| igraph_vector_bool_t VE1bool; 1374| 5.36k| igraph_integer_t i, nocuts; 1375| 5.36k| igraph_integer_t proj_nodes; 1376| 5.36k| igraph_vector_t revmap_ptr, revmap_next; 1377| 5.36k| igraph_vector_int_list_t closedsets; 1378| 5.36k| igraph_vector_int_list_t *mypartition1s = partition1s, vpartition1s; 1379| 5.36k| igraph_maxflow_stats_t stats; 1380| | 1381| | /* -------------------------------------------------------------------- */ 1382| | /* Error checks */ 1383| 5.36k| if (!igraph_is_directed(graph)) { ------------------ | Branch (1383:9): [True: 0, False: 5.36k] ------------------ 1384| 0| IGRAPH_ERROR("s-t cuts can only be listed in directed graphs.", IGRAPH_UNIMPLEMENTED); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1385| 0| } 1386| 5.36k| if (source < 0 || source >= no_of_nodes) { ------------------ | Branch (1386:9): [True: 0, False: 5.36k] | Branch (1386:23): [True: 0, False: 5.36k] ------------------ 1387| 0| IGRAPH_ERROR("Invalid source vertex.", IGRAPH_EINVVID); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1388| 0| } 1389| 5.36k| if (target < 0 || target >= no_of_nodes) { ------------------ | Branch (1389:9): [True: 0, False: 5.36k] | Branch (1389:23): [True: 0, False: 5.36k] ------------------ 1390| 0| IGRAPH_ERROR("Invalid target vertex.", IGRAPH_EINVVID); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1391| 0| } 1392| 5.36k| if (source == target) { ------------------ | Branch (1392:9): [True: 0, False: 5.36k] ------------------ 1393| 0| IGRAPH_ERROR("Source and target vertices are the same.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1394| 0| } 1395| 5.36k| if (capacity && igraph_vector_size(capacity) != no_of_edges) { ------------------ | Branch (1395:9): [True: 5.36k, False: 0] | Branch (1395:21): [True: 0, False: 5.36k] ------------------ 1396| 0| IGRAPH_ERROR("Capacity vector length must agree with number of edges.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1397| 0| } 1398| 5.36k| if (capacity && no_of_edges > 0 && igraph_vector_min(capacity) <= 0) { ------------------ | Branch (1398:9): [True: 5.36k, False: 0] | Branch (1398:21): [True: 5.36k, False: 0] | Branch (1398:40): [True: 0, False: 5.36k] ------------------ 1399| 0| IGRAPH_ERROR("Not all capacities are strictly positive.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1400| 0| } 1401| | 1402| 5.36k| if (!partition1s) { ------------------ | Branch (1402:9): [True: 5.36k, False: 0] ------------------ 1403| 5.36k| mypartition1s = &vpartition1s; 1404| 5.36k| IGRAPH_CHECK(igraph_vector_int_list_init(mypartition1s, 0)); ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1405| 5.36k| IGRAPH_FINALLY(igraph_vector_int_list_destroy, mypartition1s); ------------------ | | 695| 5.36k| do { \ | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | 699| 5.36k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 5.36k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 1406| 5.36k| } 1407| | 1408| | /* -------------------------------------------------------------------- */ 1409| | /* We need to calculate the maximum flow first */ 1410| 5.36k| IGRAPH_VECTOR_INIT_FINALLY(&flow, 0); ------------------ | | 109| 5.36k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \ | | ------------------ | | | | 752| 5.36k| do { \ | | | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 110| 5.36k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0) | | ------------------ | | | | 695| 5.36k| do { \ | | | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | | | 699| 5.36k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (110:60): [Folded - Ignored] | | ------------------ ------------------ 1411| 5.36k| IGRAPH_CHECK(igraph_maxflow(graph, value, &flow, /*cut=*/ NULL, ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1412| 5.36k| /*partition1=*/ NULL, /*partition2=*/ NULL, 1413| 5.36k| /*source=*/ source, /*target=*/ target, 1414| 5.36k| capacity, &stats)); 1415| | 1416| | /* -------------------------------------------------------------------- */ 1417| | /* Then we need the reverse residual graph */ 1418| 5.36k| IGRAPH_CHECK(igraph_reverse_residual_graph(graph, capacity, &residual, &flow)); ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1419| 5.36k| IGRAPH_FINALLY(igraph_destroy, &residual); ------------------ | | 695| 5.36k| do { \ | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | 699| 5.36k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 5.36k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 1420| | 1421| | /* -------------------------------------------------------------------- */ 1422| | /* We shrink it to its strongly connected components */ 1423| 5.36k| IGRAPH_VECTOR_INT_INIT_FINALLY(&NtoL, 0); ------------------ | | 124| 5.36k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 5.36k| do { \ | | | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 5.36k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 5.36k| do { \ | | | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | | | 699| 5.36k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 1424| 5.36k| IGRAPH_CHECK(igraph_connected_components( ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1425| 5.36k| &residual, /*membership=*/ &NtoL, /*csize=*/ NULL, 1426| 5.36k| /*no=*/ &proj_nodes, IGRAPH_STRONG 1427| 5.36k| )); 1428| 5.36k| IGRAPH_CHECK(igraph_contract_vertices(&residual, /*mapping=*/ &NtoL, /*vertex_comb=*/ NULL)); ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1429| 5.36k| IGRAPH_CHECK(igraph_simplify(&residual, /*multiple=*/ true, /*loops=*/ true, /*edge_comb=*/ NULL)); ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1430| | 1431| 5.36k| newsource = VECTOR(NtoL)[source]; ------------------ | | 69| 5.36k|#define VECTOR(v) ((v).stor_begin) ------------------ 1432| 5.36k| newtarget = VECTOR(NtoL)[target]; ------------------ | | 69| 5.36k|#define VECTOR(v) ((v).stor_begin) ------------------ 1433| | 1434| | /* TODO: handle the newsource == newtarget case */ 1435| | 1436| | /* -------------------------------------------------------------------- */ 1437| | /* Determine the active vertices in the projection */ 1438| 5.36k| IGRAPH_CHECK(igraph_vector_bool_init(&VE1bool, proj_nodes)); ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1439| 5.36k| IGRAPH_FINALLY(igraph_vector_bool_destroy, &VE1bool); ------------------ | | 695| 5.36k| do { \ | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | 699| 5.36k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 5.36k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 1440| 314k| for (i = 0; i < no_of_edges; i++) { ------------------ | Branch (1440:17): [True: 309k, False: 5.36k] ------------------ 1441| 309k| if (VECTOR(flow)[i] > 0) { ------------------ | | 69| 309k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1441:13): [True: 99.0k, False: 210k] ------------------ 1442| 99.0k| igraph_integer_t from = IGRAPH_FROM(graph, i); ------------------ | | 103| 99.0k|#define IGRAPH_FROM(graph,eid) ((igraph_integer_t)(VECTOR((graph)->from)[(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 99.0k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1443| 99.0k| igraph_integer_t to = IGRAPH_TO(graph, i); ------------------ | | 116| 99.0k|#define IGRAPH_TO(graph,eid) ((igraph_integer_t)(VECTOR((graph)->to) [(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 99.0k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1444| 99.0k| igraph_integer_t pfrom = VECTOR(NtoL)[from]; ------------------ | | 69| 99.0k|#define VECTOR(v) ((v).stor_begin) ------------------ 1445| 99.0k| igraph_integer_t pto = VECTOR(NtoL)[to]; ------------------ | | 69| 99.0k|#define VECTOR(v) ((v).stor_begin) ------------------ 1446| 99.0k| if (!VECTOR(VE1bool)[pfrom]) { ------------------ | | 69| 99.0k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1446:17): [True: 8.09k, False: 90.9k] ------------------ 1447| 8.09k| VECTOR(VE1bool)[pfrom] = true; ------------------ | | 69| 8.09k|#define VECTOR(v) ((v).stor_begin) ------------------ 1448| 8.09k| } 1449| 99.0k| if (!VECTOR(VE1bool)[pto]) { ------------------ | | 69| 99.0k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1449:17): [True: 8.46k, False: 90.6k] ------------------ 1450| 8.46k| VECTOR(VE1bool)[pto] = true; ------------------ | | 69| 8.46k|#define VECTOR(v) ((v).stor_begin) ------------------ 1451| 8.46k| } 1452| 99.0k| } 1453| 309k| } 1454| | 1455| 5.36k| if (cuts) { ------------------ | Branch (1455:9): [True: 5.36k, False: 0] ------------------ 1456| 5.36k| igraph_vector_int_list_clear(cuts); 1457| 5.36k| } 1458| 5.36k| if (partition1s) { ------------------ | Branch (1458:9): [True: 0, False: 5.36k] ------------------ 1459| 0| igraph_vector_int_list_clear(partition1s); 1460| 0| } 1461| | 1462| | /* -------------------------------------------------------------------- */ 1463| | /* Everything is ready, list the cuts, using the right PIVOT 1464| | function */ 1465| 5.36k| IGRAPH_CHECK(igraph_marked_queue_int_init(&S, no_of_nodes)); ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1466| 5.36k| IGRAPH_FINALLY(igraph_marked_queue_int_destroy, &S); ------------------ | | 695| 5.36k| do { \ | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | 699| 5.36k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 5.36k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 1467| 5.36k| IGRAPH_CHECK(igraph_estack_init(&T, no_of_nodes, 0)); ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1468| 5.36k| IGRAPH_FINALLY(igraph_estack_destroy, &T); ------------------ | | 695| 5.36k| do { \ | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | 699| 5.36k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 5.36k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 1469| 5.36k| IGRAPH_VECTOR_INT_INIT_FINALLY(&cut, 0); ------------------ | | 124| 5.36k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 5.36k| do { \ | | | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 5.36k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 5.36k| do { \ | | | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | | | 699| 5.36k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 1470| | 1471| 5.36k| pivot_data.active = &VE1bool; 1472| | 1473| 5.36k| IGRAPH_VECTOR_INT_LIST_INIT_FINALLY(&closedsets, 0); ------------------ | | 68| 5.36k| do { IGRAPH_CHECK(igraph_vector_int_list_init(v, size)); \ | | ------------------ | | | | 752| 5.36k| do { \ | | | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 69| 5.36k| IGRAPH_FINALLY(igraph_vector_int_list_destroy, v); } while (0) | | ------------------ | | | | 695| 5.36k| do { \ | | | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | | | 699| 5.36k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (69:69): [Folded - Ignored] | | ------------------ ------------------ 1474| 5.36k| IGRAPH_CHECK(igraph_provan_shier_list(&residual, &S, &T, ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1475| 5.36k| newsource, newtarget, &closedsets, 1476| 5.36k| igraph_i_all_st_mincuts_pivot, 1477| 5.36k| &pivot_data)); 1478| | 1479| | /* Convert the closed sets in the contracted graphs to cutsets in the 1480| | original graph */ 1481| 5.36k| IGRAPH_VECTOR_INIT_FINALLY(&revmap_ptr, igraph_vcount(&residual)); ------------------ | | 109| 5.36k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \ | | ------------------ | | | | 752| 5.36k| do { \ | | | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 110| 5.36k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0) | | ------------------ | | | | 695| 5.36k| do { \ | | | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | | | 699| 5.36k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (110:60): [Folded - Ignored] | | ------------------ ------------------ 1482| 5.36k| IGRAPH_VECTOR_INIT_FINALLY(&revmap_next, no_of_nodes); ------------------ | | 109| 5.36k| do { IGRAPH_CHECK(igraph_vector_init(v, size)); \ | | ------------------ | | | | 752| 5.36k| do { \ | | | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 110| 5.36k| IGRAPH_FINALLY(igraph_vector_destroy, v); } while (0) | | ------------------ | | | | 695| 5.36k| do { \ | | | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | | | 699| 5.36k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (110:60): [Folded - Ignored] | | ------------------ ------------------ 1483| 133k| for (i = 0; i < no_of_nodes; i++) { ------------------ | Branch (1483:17): [True: 127k, False: 5.36k] ------------------ 1484| 127k| igraph_integer_t id = VECTOR(NtoL)[i]; ------------------ | | 69| 127k|#define VECTOR(v) ((v).stor_begin) ------------------ 1485| 127k| VECTOR(revmap_next)[i] = VECTOR(revmap_ptr)[id]; ------------------ | | 69| 127k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(revmap_next)[i] = VECTOR(revmap_ptr)[id]; ------------------ | | 69| 127k|#define VECTOR(v) ((v).stor_begin) ------------------ 1486| 127k| VECTOR(revmap_ptr)[id] = i + 1; ------------------ | | 69| 127k|#define VECTOR(v) ((v).stor_begin) ------------------ 1487| 127k| } 1488| | 1489| | /* Create partitions in original graph */ 1490| 5.36k| nocuts = igraph_vector_int_list_size(&closedsets); 1491| 5.36k| igraph_vector_int_list_clear(mypartition1s); 1492| 5.36k| IGRAPH_CHECK(igraph_vector_int_list_reserve(mypartition1s, nocuts)); ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1493| 19.2k| for (i = 0; i < nocuts; i++) { ------------------ | Branch (1493:17): [True: 13.8k, False: 5.36k] ------------------ 1494| 13.8k| igraph_vector_int_t *supercut = igraph_vector_int_list_get_ptr(&closedsets, i); 1495| 13.8k| igraph_integer_t j, supercutsize = igraph_vector_int_size(supercut); 1496| | 1497| 13.8k| igraph_vector_int_clear(&cut); 1498| 57.7k| for (j = 0; j < supercutsize; j++) { ------------------ | Branch (1498:21): [True: 43.9k, False: 13.8k] ------------------ 1499| 43.9k| igraph_integer_t vtx = VECTOR(*supercut)[j]; ------------------ | | 69| 43.9k|#define VECTOR(v) ((v).stor_begin) ------------------ 1500| 43.9k| igraph_integer_t ovtx = VECTOR(revmap_ptr)[vtx]; ------------------ | | 69| 43.9k|#define VECTOR(v) ((v).stor_begin) ------------------ 1501| 267k| while (ovtx != 0) { ------------------ | Branch (1501:20): [True: 223k, False: 43.9k] ------------------ 1502| 223k| ovtx--; 1503| 223k| IGRAPH_CHECK(igraph_vector_int_push_back(&cut, ovtx)); ------------------ | | 752| 223k| do { \ | | 753| 223k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 223k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 223k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 223k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 223k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1504| 223k| ovtx = VECTOR(revmap_next)[ovtx]; ------------------ | | 69| 223k|#define VECTOR(v) ((v).stor_begin) ------------------ 1505| 223k| } 1506| 43.9k| } 1507| | 1508| 13.8k| IGRAPH_CHECK(igraph_vector_int_list_push_back_copy(mypartition1s, &cut)); ------------------ | | 752| 13.8k| do { \ | | 753| 13.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 13.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 13.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1509| | 1510| | /* TODO: we could already reclaim the memory taken by 'supercut' here */ 1511| 13.8k| } 1512| | 1513| 5.36k| igraph_vector_destroy(&revmap_next); 1514| 5.36k| igraph_vector_destroy(&revmap_ptr); 1515| 5.36k| igraph_vector_int_list_destroy(&closedsets); 1516| 5.36k| IGRAPH_FINALLY_CLEAN(3); 1517| | 1518| | /* Create cuts in original graph */ 1519| 5.36k| if (cuts) { ------------------ | Branch (1519:9): [True: 5.36k, False: 0] ------------------ 1520| 5.36k| igraph_vector_int_t memb; 1521| | 1522| 5.36k| IGRAPH_VECTOR_INT_INIT_FINALLY(&memb, no_of_nodes); ------------------ | | 124| 5.36k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 5.36k| do { \ | | | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 5.36k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 5.36k| do { \ | | | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | | | 699| 5.36k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 1523| 5.36k| IGRAPH_CHECK(igraph_vector_int_list_reserve(cuts, nocuts)); ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1524| | 1525| 19.2k| for (i = 0; i < nocuts; i++) { ------------------ | Branch (1525:21): [True: 13.8k, False: 5.36k] ------------------ 1526| 13.8k| igraph_vector_int_t *part = igraph_vector_int_list_get_ptr(mypartition1s, i); 1527| 13.8k| igraph_integer_t j, n = igraph_vector_int_size(part); 1528| | 1529| 13.8k| igraph_vector_int_clear(&cut); 1530| 237k| for (j = 0; j < n; j++) { ------------------ | Branch (1530:25): [True: 223k, False: 13.8k] ------------------ 1531| 223k| igraph_integer_t vtx = VECTOR(*part)[j]; ------------------ | | 69| 223k|#define VECTOR(v) ((v).stor_begin) ------------------ 1532| 223k| VECTOR(memb)[vtx] = i + 1; ------------------ | | 69| 223k|#define VECTOR(v) ((v).stor_begin) ------------------ 1533| 223k| } 1534| 711k| for (j = 0; j < no_of_edges; j++) { ------------------ | Branch (1534:25): [True: 697k, False: 13.8k] ------------------ 1535| 697k| if (VECTOR(flow)[j] > 0) { ------------------ | | 69| 697k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1535:21): [True: 284k, False: 413k] ------------------ 1536| 284k| igraph_integer_t from = IGRAPH_FROM(graph, j); ------------------ | | 103| 284k|#define IGRAPH_FROM(graph,eid) ((igraph_integer_t)(VECTOR((graph)->from)[(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 284k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1537| 284k| igraph_integer_t to = IGRAPH_TO(graph, j); ------------------ | | 116| 284k|#define IGRAPH_TO(graph,eid) ((igraph_integer_t)(VECTOR((graph)->to) [(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 284k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1538| 284k| if (VECTOR(memb)[from] == i + 1 && VECTOR(memb)[to] != i + 1) { ------------------ | | 69| 284k|#define VECTOR(v) ((v).stor_begin) ------------------ if (VECTOR(memb)[from] == i + 1 && VECTOR(memb)[to] != i + 1) { ------------------ | | 69| 200k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1538:25): [True: 200k, False: 83.5k] | Branch (1538:56): [True: 31.2k, False: 169k] ------------------ 1539| 31.2k| IGRAPH_CHECK(igraph_vector_int_push_back(&cut, j)); ------------------ | | 752| 31.2k| do { \ | | 753| 31.2k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 31.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 31.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 31.2k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 31.2k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1540| 31.2k| } 1541| 284k| } 1542| 697k| } 1543| | 1544| 13.8k| IGRAPH_CHECK(igraph_vector_int_list_push_back_copy(cuts, &cut)); ------------------ | | 752| 13.8k| do { \ | | 753| 13.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 13.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 13.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1545| 13.8k| } 1546| | 1547| 5.36k| igraph_vector_int_destroy(&memb); 1548| 5.36k| IGRAPH_FINALLY_CLEAN(1); 1549| 5.36k| } 1550| | 1551| 5.36k| igraph_vector_int_destroy(&cut); 1552| 5.36k| igraph_estack_destroy(&T); 1553| 5.36k| igraph_marked_queue_int_destroy(&S); 1554| 5.36k| igraph_vector_bool_destroy(&VE1bool); 1555| 5.36k| igraph_vector_int_destroy(&NtoL); 1556| 5.36k| igraph_destroy(&residual); 1557| 5.36k| igraph_vector_destroy(&flow); 1558| 5.36k| IGRAPH_FINALLY_CLEAN(7); 1559| | 1560| 5.36k| if (!partition1s) { ------------------ | Branch (1560:9): [True: 5.36k, False: 0] ------------------ 1561| 5.36k| igraph_vector_int_list_destroy(mypartition1s); 1562| 5.36k| IGRAPH_FINALLY_CLEAN(1); 1563| 5.36k| } 1564| | 1565| 5.36k| return IGRAPH_SUCCESS; 1566| 5.36k|} st-cuts.c:igraph_i_reverse_residual_graph: 222| 5.36k| igraph_vector_int_t *tmp) { 223| | 224| 5.36k| igraph_integer_t no_of_nodes = igraph_vcount(graph); 225| 5.36k| igraph_integer_t no_of_edges = igraph_ecount(graph); 226| 5.36k| igraph_integer_t i, no_new_edges = 0; 227| 5.36k| igraph_integer_t edgeptr = 0; 228| | 229| 314k| for (i = 0; i < no_of_edges; i++) { ------------------ | Branch (229:17): [True: 309k, False: 5.36k] ------------------ 230| 309k| igraph_real_t cap = capacity ? VECTOR(*capacity)[i] : 1.0; ------------------ | | 69| 309k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (230:29): [True: 309k, False: 0] ------------------ 231| 309k| if (VECTOR(*flow)[i] > 0) { ------------------ | | 69| 309k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (231:13): [True: 99.0k, False: 210k] ------------------ 232| 99.0k| no_new_edges++; 233| 99.0k| } 234| 309k| if (VECTOR(*flow)[i] < cap) { ------------------ | | 69| 309k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (234:13): [True: 266k, False: 42.9k] ------------------ 235| 266k| no_new_edges++; 236| 266k| } 237| 309k| } 238| | 239| 5.36k| IGRAPH_CHECK(igraph_vector_int_resize(tmp, no_new_edges * 2)); ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 240| | 241| 314k| for (i = 0; i < no_of_edges; i++) { ------------------ | Branch (241:17): [True: 309k, False: 5.36k] ------------------ 242| 309k| igraph_integer_t from = IGRAPH_FROM(graph, i); ------------------ | | 103| 309k|#define IGRAPH_FROM(graph,eid) ((igraph_integer_t)(VECTOR((graph)->from)[(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 309k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 243| 309k| igraph_integer_t to = IGRAPH_TO(graph, i); ------------------ | | 116| 309k|#define IGRAPH_TO(graph,eid) ((igraph_integer_t)(VECTOR((graph)->to) [(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 309k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 244| 309k| igraph_real_t cap = capacity ? VECTOR(*capacity)[i] : 1.0; ------------------ | | 69| 309k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (244:29): [True: 309k, False: 0] ------------------ 245| 309k| if (VECTOR(*flow)[i] > 0) { ------------------ | | 69| 309k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (245:13): [True: 99.0k, False: 210k] ------------------ 246| 99.0k| VECTOR(*tmp)[edgeptr++] = from; ------------------ | | 69| 99.0k|#define VECTOR(v) ((v).stor_begin) ------------------ 247| 99.0k| VECTOR(*tmp)[edgeptr++] = to; ------------------ | | 69| 99.0k|#define VECTOR(v) ((v).stor_begin) ------------------ 248| 99.0k| } 249| 309k| if (VECTOR(*flow)[i] < cap) { ------------------ | | 69| 309k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (249:13): [True: 266k, False: 42.9k] ------------------ 250| 266k| VECTOR(*tmp)[edgeptr++] = to; ------------------ | | 69| 266k|#define VECTOR(v) ((v).stor_begin) ------------------ 251| 266k| VECTOR(*tmp)[edgeptr++] = from; ------------------ | | 69| 266k|#define VECTOR(v) ((v).stor_begin) ------------------ 252| 266k| } 253| 309k| } 254| | 255| 5.36k| IGRAPH_CHECK(igraph_create(residual, tmp, no_of_nodes, ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 256| 5.36k| IGRAPH_DIRECTED)); 257| | 258| 5.36k| return IGRAPH_SUCCESS; 259| 5.36k|} st-cuts.c:igraph_provan_shier_list: 988| 5.36k|) { 989| 5.36k| igraph_vector_int_t Isv; 990| | 991| 5.36k| IGRAPH_VECTOR_INT_INIT_FINALLY(&Isv, 0); ------------------ | | 124| 5.36k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 5.36k| do { \ | | | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 5.36k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 5.36k| do { \ | | | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | | | 699| 5.36k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 992| | 993| 5.36k| IGRAPH_CHECK(igraph_i_provan_shier_list_recursive( ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 994| 5.36k| graph, S, T, source, target, result, pivot, &Isv, pivot_arg 995| 5.36k| )); 996| | 997| | /* Reverse the result to stay compatible with versions before 0.10.3 */ 998| 5.36k| IGRAPH_CHECK(igraph_vector_int_list_reverse(result)); ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 999| | 1000| 5.36k| igraph_vector_int_destroy(&Isv); 1001| 5.36k| IGRAPH_FINALLY_CLEAN(1); 1002| | 1003| 5.36k| return IGRAPH_SUCCESS; 1004| 5.36k|} st-cuts.c:igraph_i_provan_shier_list_recursive: 936| 33.1k|) { 937| | 938| 33.1k| igraph_integer_t no_of_nodes = igraph_vcount(graph); 939| 33.1k| igraph_integer_t v = 0; 940| 33.1k| igraph_integer_t i, n; 941| | 942| 33.1k| pivot(graph, S, T, source, target, &v, Isv, pivot_arg); 943| | 944| 33.1k| if (igraph_vector_int_empty(Isv)) { ------------------ | Branch (944:9): [True: 19.2k, False: 13.8k] ------------------ 945| 19.2k| if (igraph_marked_queue_int_size(S) != 0 && igraph_marked_queue_int_size(S) != no_of_nodes) { ------------------ | Branch (945:13): [True: 13.8k, False: 5.36k] | Branch (945:53): [True: 13.8k, False: 0] ------------------ 946| 13.8k| igraph_vector_int_t *vec; 947| 13.8k| IGRAPH_CHECK(igraph_vector_int_list_push_back_new(result, &vec)); ------------------ | | 752| 13.8k| do { \ | | 753| 13.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 13.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 13.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 948| 13.8k| IGRAPH_CHECK(igraph_marked_queue_int_as_vector(S, vec)); ------------------ | | 752| 13.8k| do { \ | | 753| 13.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 13.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 13.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 949| 13.8k| } 950| 19.2k| } else { 951| | /* Add Isv to S */ 952| 13.8k| IGRAPH_CHECK(igraph_marked_queue_int_start_batch(S)); ------------------ | | 752| 13.8k| do { \ | | 753| 13.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 13.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 13.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 953| 13.8k| n = igraph_vector_int_size(Isv); 954| 28.9k| for (i = 0; i < n; i++) { ------------------ | Branch (954:21): [True: 15.0k, False: 13.8k] ------------------ 955| 15.0k| if (!igraph_marked_queue_int_iselement(S, VECTOR(*Isv)[i])) { ------------------ | | 69| 15.0k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (955:17): [True: 15.0k, False: 0] ------------------ 956| 15.0k| IGRAPH_CHECK(igraph_marked_queue_int_push(S, VECTOR(*Isv)[i])); ------------------ | | 752| 15.0k| do { \ | | 753| 15.0k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 15.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 15.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 15.0k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 15.0k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 957| 15.0k| } 958| 15.0k| } 959| 13.8k| igraph_vector_int_clear(Isv); 960| | 961| | /* Go down right in the search tree */ 962| 13.8k| IGRAPH_CHECK(igraph_i_provan_shier_list_recursive( ------------------ | | 752| 13.8k| do { \ | | 753| 13.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 13.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 13.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 963| 13.8k| graph, S, T, source, target, result, pivot, Isv, pivot_arg)); 964| | 965| | /* Take out Isv from S */ 966| 13.8k| igraph_marked_queue_int_pop_back_batch(S); 967| | 968| | /* Put v into T */ 969| 13.8k| IGRAPH_CHECK(igraph_estack_push(T, v)); ------------------ | | 752| 13.8k| do { \ | | 753| 13.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 13.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 13.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 970| | 971| | /* Go down left in the search tree */ 972| 13.8k| IGRAPH_CHECK(igraph_i_provan_shier_list_recursive( ------------------ | | 752| 13.8k| do { \ | | 753| 13.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 13.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 13.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 973| 13.8k| graph, S, T, source, target, result, pivot, Isv, pivot_arg)); 974| | 975| | /* Take out v from T */ 976| 13.8k| igraph_estack_pop(T); 977| | 978| 13.8k| } 979| | 980| 33.1k| return IGRAPH_SUCCESS; 981| 33.1k|} st-cuts.c:igraph_i_all_st_mincuts_pivot: 1217| 33.1k| void *arg) { 1218| | 1219| 33.1k| igraph_i_all_st_mincuts_data_t *data = arg; 1220| 33.1k| const igraph_vector_bool_t *active = data->active; 1221| | 1222| 33.1k| igraph_integer_t no_of_nodes = igraph_vcount(graph); 1223| 33.1k| igraph_integer_t i, j; 1224| 33.1k| igraph_vector_int_t Sbar_map, Sbar_invmap; 1225| 33.1k| igraph_vector_int_t keep; 1226| 33.1k| igraph_t Sbar; 1227| 33.1k| igraph_vector_int_t M; 1228| 33.1k| igraph_integer_t nomin; 1229| | 1230| 33.1k| IGRAPH_UNUSED(source); IGRAPH_UNUSED(target); ------------------ | | 12| 33.1k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ IGRAPH_UNUSED(source); IGRAPH_UNUSED(target); ------------------ | | 12| 33.1k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 1231| | 1232| 33.1k| if (igraph_marked_queue_int_size(S) == no_of_nodes) { ------------------ | Branch (1232:9): [True: 0, False: 33.1k] ------------------ 1233| 0| igraph_vector_int_clear(Isv); 1234| 0| return IGRAPH_SUCCESS; 1235| 0| } 1236| | 1237| | /* Create the graph induced by Sbar */ 1238| 33.1k| IGRAPH_VECTOR_INT_INIT_FINALLY(&Sbar_map, 0); ------------------ | | 124| 33.1k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 33.1k| do { \ | | | | 753| 33.1k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 33.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 33.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 33.1k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 33.1k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 33.1k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 33.1k| do { \ | | | | 696| 33.1k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 33.1k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 33.1k| * incorrect destructor function with the pointer */ \ | | | | 699| 33.1k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 33.1k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 33.1k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 1239| 33.1k| IGRAPH_VECTOR_INT_INIT_FINALLY(&Sbar_invmap, 0); ------------------ | | 124| 33.1k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 33.1k| do { \ | | | | 753| 33.1k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 33.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 33.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 33.1k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 33.1k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 33.1k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 33.1k| do { \ | | | | 696| 33.1k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 33.1k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 33.1k| * incorrect destructor function with the pointer */ \ | | | | 699| 33.1k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 33.1k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 33.1k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 1240| | 1241| 33.1k| IGRAPH_VECTOR_INT_INIT_FINALLY(&keep, 0); ------------------ | | 124| 33.1k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 33.1k| do { \ | | | | 753| 33.1k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 33.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 33.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 33.1k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 33.1k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 33.1k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 33.1k| do { \ | | | | 696| 33.1k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 33.1k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 33.1k| * incorrect destructor function with the pointer */ \ | | | | 699| 33.1k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 33.1k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 33.1k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 1242| 249k| for (i = 0; i < no_of_nodes; i++) { ------------------ | Branch (1242:17): [True: 216k, False: 33.1k] ------------------ 1243| 216k| if (!igraph_marked_queue_int_iselement(S, i)) { ------------------ | Branch (1243:13): [True: 144k, False: 72.7k] ------------------ 1244| 144k| IGRAPH_CHECK(igraph_vector_int_push_back(&keep, i)); ------------------ | | 752| 144k| do { \ | | 753| 144k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 144k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 144k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 144k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 144k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1245| 144k| } 1246| 216k| } 1247| | 1248| | /* TODO: it is not even necessary to create Sbar explicitly, we 1249| | just need to find the M elements efficiently. See the 1250| | Provan-Shier paper for details. */ 1251| 33.1k| IGRAPH_CHECK(igraph_induced_subgraph_map(graph, &Sbar, ------------------ | | 752| 33.1k| do { \ | | 753| 33.1k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 33.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 33.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 33.1k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 33.1k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1252| 33.1k| igraph_vss_vector(&keep), 1253| 33.1k| IGRAPH_SUBGRAPH_AUTO, 1254| 33.1k| /* map= */ &Sbar_map, 1255| 33.1k| /* invmap= */ &Sbar_invmap)); 1256| 33.1k| IGRAPH_FINALLY(igraph_destroy, &Sbar); ------------------ | | 695| 33.1k| do { \ | | 696| 33.1k| /* the following branch makes the compiler check the compatibility of \ | | 697| 33.1k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 33.1k| * incorrect destructor function with the pointer */ \ | | 699| 33.1k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 33.1k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 33.1k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 1257| | 1258| | /* ------------------------------------------------------------- */ 1259| | /* Identify the set M of minimal elements that are active */ 1260| 33.1k| IGRAPH_VECTOR_INT_INIT_FINALLY(&M, 0); ------------------ | | 124| 33.1k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 33.1k| do { \ | | | | 753| 33.1k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 33.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 33.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 33.1k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 33.1k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 33.1k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 33.1k| do { \ | | | | 696| 33.1k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 33.1k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 33.1k| * incorrect destructor function with the pointer */ \ | | | | 699| 33.1k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 33.1k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 33.1k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 1261| 33.1k| IGRAPH_CHECK(igraph_i_all_st_mincuts_minimal(&Sbar, active, ------------------ | | 752| 33.1k| do { \ | | 753| 33.1k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 33.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 33.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 33.1k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 33.1k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1262| 33.1k| &Sbar_invmap, &M)); 1263| | 1264| | /* ------------------------------------------------------------- */ 1265| | /* Now find a minimal element that is not in T */ 1266| 33.1k| igraph_vector_int_clear(Isv); 1267| 33.1k| nomin = igraph_vector_int_size(&M); 1268| 57.9k| for (i = 0; i < nomin; i++) { ------------------ | Branch (1268:17): [True: 38.6k, False: 19.2k] ------------------ 1269| 38.6k| igraph_integer_t min = VECTOR(Sbar_invmap)[ VECTOR(M)[i] ]; ------------------ | | 69| 38.6k|#define VECTOR(v) ((v).stor_begin) ------------------ igraph_integer_t min = VECTOR(Sbar_invmap)[ VECTOR(M)[i] ]; ------------------ | | 69| 38.6k|#define VECTOR(v) ((v).stor_begin) ------------------ 1270| 38.6k| if (min != target) ------------------ | Branch (1270:13): [True: 33.2k, False: 5.40k] ------------------ 1271| 33.2k| if (!igraph_estack_iselement(T, min)) { ------------------ | Branch (1271:17): [True: 13.8k, False: 19.3k] ------------------ 1272| 13.8k| break; 1273| 13.8k| } 1274| 38.6k| } 1275| 33.1k| if (i != nomin) { ------------------ | Branch (1275:9): [True: 13.8k, False: 19.2k] ------------------ 1276| | /* OK, we found a pivot element. I(S,v) contains all elements 1277| | that can reach the pivot element */ 1278| 13.8k| igraph_vector_int_t Isv_min; 1279| 13.8k| IGRAPH_VECTOR_INT_INIT_FINALLY(&Isv_min, 0); ------------------ | | 124| 13.8k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 13.8k| do { \ | | | | 753| 13.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 13.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 13.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 13.8k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 13.8k| do { \ | | | | 696| 13.8k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 13.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 13.8k| * incorrect destructor function with the pointer */ \ | | | | 699| 13.8k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 13.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 13.8k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 1280| 13.8k| *v = VECTOR(Sbar_invmap)[ VECTOR(M)[i] ]; ------------------ | | 69| 13.8k|#define VECTOR(v) ((v).stor_begin) ------------------ *v = VECTOR(Sbar_invmap)[ VECTOR(M)[i] ]; ------------------ | | 69| 13.8k|#define VECTOR(v) ((v).stor_begin) ------------------ 1281| | /* TODO: restricted == keep ? */ 1282| 13.8k| IGRAPH_CHECK(igraph_bfs(graph, /*root=*/ *v,/*roots=*/ NULL, ------------------ | | 752| 13.8k| do { \ | | 753| 13.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 13.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 13.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1283| 13.8k| /*mode=*/ IGRAPH_IN, /*unreachable=*/ false, 1284| 13.8k| /*restricted=*/ &keep, /*order=*/ &Isv_min, 1285| 13.8k| /*rank=*/ NULL, /*parents=*/ NULL, /*pred=*/ NULL, 1286| 13.8k| /*succ=*/ NULL, /*dist=*/ NULL, /*callback=*/ NULL, 1287| 13.8k| /*extra=*/ NULL)); 1288| 29.1k| for (j = 0; j < no_of_nodes; j++) { ------------------ | Branch (1288:21): [True: 29.1k, False: 0] ------------------ 1289| 29.1k| igraph_integer_t u = VECTOR(Isv_min)[j]; ------------------ | | 69| 29.1k|#define VECTOR(v) ((v).stor_begin) ------------------ 1290| 29.1k| if (u < 0) { ------------------ | Branch (1290:17): [True: 13.8k, False: 15.2k] ------------------ 1291| 13.8k| break; 1292| 13.8k| } 1293| 15.2k| if (!igraph_estack_iselement(T, u)) { ------------------ | Branch (1293:17): [True: 15.0k, False: 229] ------------------ 1294| 15.0k| IGRAPH_CHECK(igraph_vector_int_push_back(Isv, u)); ------------------ | | 752| 15.0k| do { \ | | 753| 15.0k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 15.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 15.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 15.0k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 15.0k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1295| 15.0k| } 1296| 15.2k| } 1297| 13.8k| igraph_vector_int_destroy(&Isv_min); 1298| 13.8k| IGRAPH_FINALLY_CLEAN(1); 1299| 13.8k| } 1300| | 1301| 33.1k| igraph_vector_int_destroy(&M); 1302| 33.1k| igraph_destroy(&Sbar); 1303| 33.1k| igraph_vector_int_destroy(&keep); 1304| 33.1k| igraph_vector_int_destroy(&Sbar_invmap); 1305| 33.1k| igraph_vector_int_destroy(&Sbar_map); 1306| 33.1k| IGRAPH_FINALLY_CLEAN(5); 1307| | 1308| 33.1k| return IGRAPH_SUCCESS; 1309| 33.1k|} st-cuts.c:igraph_i_all_st_mincuts_minimal: 1154| 33.1k| igraph_vector_int_t *minimal) { 1155| | 1156| 33.1k| igraph_integer_t no_of_nodes = igraph_vcount(Sbar); 1157| 33.1k| igraph_vector_int_t indeg; 1158| 33.1k| igraph_integer_t i, minsize; 1159| 33.1k| igraph_vector_int_t neis; 1160| | 1161| 33.1k| IGRAPH_VECTOR_INT_INIT_FINALLY(&neis, 0); ------------------ | | 124| 33.1k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 33.1k| do { \ | | | | 753| 33.1k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 33.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 33.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 33.1k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 33.1k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 33.1k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 33.1k| do { \ | | | | 696| 33.1k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 33.1k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 33.1k| * incorrect destructor function with the pointer */ \ | | | | 699| 33.1k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 33.1k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 33.1k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 1162| 33.1k| IGRAPH_VECTOR_INT_INIT_FINALLY(&indeg, no_of_nodes); ------------------ | | 124| 33.1k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 33.1k| do { \ | | | | 753| 33.1k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 33.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 33.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 33.1k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 33.1k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 33.1k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 33.1k| do { \ | | | | 696| 33.1k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 33.1k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 33.1k| * incorrect destructor function with the pointer */ \ | | | | 699| 33.1k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 33.1k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 33.1k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 1163| | 1164| 33.1k| IGRAPH_CHECK(igraph_degree(Sbar, &indeg, igraph_vss_all(), ------------------ | | 752| 33.1k| do { \ | | 753| 33.1k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 33.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 33.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 33.1k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 33.1k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1165| 33.1k| IGRAPH_IN, /*loops=*/ 1)); 1166| | 1167| 33.1k|#define ACTIVE(x) (VECTOR(*active)[VECTOR(*invmap)[(x)]]) 1168| 33.1k|#define ZEROIN(x) (VECTOR(indeg)[(x)]==0) 1169| | 1170| 177k| for (i = 0; i < no_of_nodes; i++) { ------------------ | Branch (1170:17): [True: 144k, False: 33.1k] ------------------ 1171| 144k| if (!ACTIVE(i)) { ------------------ | | 1167| 144k|#define ACTIVE(x) (VECTOR(*active)[VECTOR(*invmap)[(x)]]) | | ------------------ | | | | 69| 144k|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | #define ACTIVE(x) (VECTOR(*active)[VECTOR(*invmap)[(x)]]) | | ------------------ | | | | 69| 144k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (1171:13): [True: 33.8k, False: 110k] ------------------ 1172| 33.8k| igraph_integer_t j, n; 1173| 33.8k| IGRAPH_CHECK(igraph_neighbors(Sbar, &neis, i, IGRAPH_OUT)); ------------------ | | 752| 33.8k| do { \ | | 753| 33.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 33.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 33.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 33.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 33.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1174| 33.8k| n = igraph_vector_int_size(&neis); 1175| 70.4k| for (j = 0; j < n; j++) { ------------------ | Branch (1175:25): [True: 36.6k, False: 33.8k] ------------------ 1176| 36.6k| igraph_integer_t nei = VECTOR(neis)[j]; ------------------ | | 69| 36.6k|#define VECTOR(v) ((v).stor_begin) ------------------ 1177| 36.6k| VECTOR(indeg)[nei] -= 1; ------------------ | | 69| 36.6k|#define VECTOR(v) ((v).stor_begin) ------------------ 1178| 36.6k| } 1179| 33.8k| } 1180| 144k| } 1181| | 1182| 177k| for (minsize = 0, i = 0; i < no_of_nodes; i++) { ------------------ | Branch (1182:30): [True: 144k, False: 33.1k] ------------------ 1183| 144k| if (ACTIVE(i) && ZEROIN(i)) { ------------------ | | 1167| 288k|#define ACTIVE(x) (VECTOR(*active)[VECTOR(*invmap)[(x)]]) | | ------------------ | | | | 69| 144k|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | #define ACTIVE(x) (VECTOR(*active)[VECTOR(*invmap)[(x)]]) | | ------------------ | | | | 69| 144k|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | | Branch (1167:19): [True: 110k, False: 33.8k] | | ------------------ ------------------ if (ACTIVE(i) && ZEROIN(i)) { ------------------ | | 1168| 110k|#define ZEROIN(x) (VECTOR(indeg)[(x)]==0) | | ------------------ | | | | 69| 110k|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | | Branch (1168:19): [True: 40.0k, False: 70.1k] | | ------------------ ------------------ 1184| 40.0k| minsize++; 1185| 40.0k| } 1186| 144k| } 1187| | 1188| 33.1k| IGRAPH_CHECK(igraph_vector_int_resize(minimal, minsize)); ------------------ | | 752| 33.1k| do { \ | | 753| 33.1k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 33.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 33.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 33.1k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 33.1k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1189| | 1190| 177k| for (minsize = 0, i = 0; i < no_of_nodes; i++) { ------------------ | Branch (1190:30): [True: 144k, False: 33.1k] ------------------ 1191| 144k| if (ACTIVE(i) && ZEROIN(i)) { ------------------ | | 1167| 288k|#define ACTIVE(x) (VECTOR(*active)[VECTOR(*invmap)[(x)]]) | | ------------------ | | | | 69| 144k|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | #define ACTIVE(x) (VECTOR(*active)[VECTOR(*invmap)[(x)]]) | | ------------------ | | | | 69| 144k|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | | Branch (1167:19): [True: 110k, False: 33.8k] | | ------------------ ------------------ if (ACTIVE(i) && ZEROIN(i)) { ------------------ | | 1168| 110k|#define ZEROIN(x) (VECTOR(indeg)[(x)]==0) | | ------------------ | | | | 69| 110k|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | | Branch (1168:19): [True: 40.0k, False: 70.1k] | | ------------------ ------------------ 1192| 40.0k| VECTOR(*minimal)[minsize++] = i; ------------------ | | 69| 40.0k|#define VECTOR(v) ((v).stor_begin) ------------------ 1193| 40.0k| } 1194| 144k| } 1195| | 1196| 33.1k|#undef ACTIVE 1197| 33.1k|#undef ZEROIN 1198| | 1199| 33.1k| igraph_vector_int_destroy(&indeg); 1200| 33.1k| igraph_vector_int_destroy(&neis); 1201| 33.1k| IGRAPH_FINALLY_CLEAN(2); 1202| | 1203| 33.1k| return IGRAPH_SUCCESS; 1204| 33.1k|} igraph_adjlist_init: 158| 11.8k| igraph_multiple_t multiple) { 159| 11.8k| igraph_integer_t no_of_nodes = igraph_vcount(graph); 160| 11.8k| igraph_vector_int_t degrees; 161| | 162| 11.8k| if (mode != IGRAPH_IN && mode != IGRAPH_OUT && mode != IGRAPH_ALL) { ------------------ | Branch (162:9): [True: 6.52k, False: 5.36k] | Branch (162:30): [True: 1.15k, False: 5.36k] | Branch (162:52): [True: 0, False: 1.15k] ------------------ 163| 0| IGRAPH_ERROR("Cannot create adjacency list view.", IGRAPH_EINVMODE); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 164| 0| } 165| | 166| 11.8k| if (!igraph_is_directed(graph)) { ------------------ | Branch (166:9): [True: 1.15k, False: 10.7k] ------------------ 167| 1.15k| mode = IGRAPH_ALL; 168| 1.15k| } 169| | 170| 11.8k| IGRAPH_VECTOR_INT_INIT_FINALLY(°rees, no_of_nodes); ------------------ | | 124| 11.8k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 11.8k| do { \ | | | | 753| 11.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 11.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 11.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 11.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 11.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 11.8k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 11.8k| do { \ | | | | 696| 11.8k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 11.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 11.8k| * incorrect destructor function with the pointer */ \ | | | | 699| 11.8k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 11.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 11.8k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 171| | /* igraph_degree() is fast when loops=true */ 172| 11.8k| IGRAPH_CHECK(igraph_degree(graph, °rees, igraph_vss_all(), mode, /* loops= */ true)); ------------------ | | 752| 11.8k| do { \ | | 753| 11.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 11.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 11.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 11.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 11.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 173| | 174| 11.8k| al->length = no_of_nodes; 175| 11.8k| al->adjs = IGRAPH_CALLOC(al->length, igraph_vector_int_t); ------------------ | | 32| 11.8k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [True: 11.8k, False: 0] | | ------------------ ------------------ 176| 11.8k| IGRAPH_CHECK_OOM(al->adjs, "Insufficient memory for creating adjacency list view."); ------------------ | | 807| 11.8k| do { \ | | 808| 11.8k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 11.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 11.8k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 11.8k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 177| 11.8k| IGRAPH_FINALLY(igraph_adjlist_destroy, al); ------------------ | | 695| 11.8k| do { \ | | 696| 11.8k| /* the following branch makes the compiler check the compatibility of \ | | 697| 11.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 11.8k| * incorrect destructor function with the pointer */ \ | | 699| 11.8k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 11.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 11.8k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 178| | 179| | /* if we already know there are no multi-edges, they don't need to be removed */ 180| 11.8k| if (igraph_i_property_cache_has(graph, IGRAPH_PROP_HAS_MULTI) && ------------------ | Branch (180:9): [True: 0, False: 11.8k] ------------------ 181| 11.8k| !igraph_i_property_cache_get_bool(graph, IGRAPH_PROP_HAS_MULTI)) { ------------------ | Branch (181:9): [True: 0, False: 0] ------------------ 182| 0| multiple = IGRAPH_MULTIPLE; 183| 0| } 184| | 185| | /* if we already know there are no loops, they don't need to be removed */ 186| 11.8k| if (igraph_i_property_cache_has(graph, IGRAPH_PROP_HAS_LOOP) && ------------------ | Branch (186:9): [True: 0, False: 11.8k] ------------------ 187| 11.8k| !igraph_i_property_cache_get_bool(graph, IGRAPH_PROP_HAS_LOOP)) { ------------------ | Branch (187:9): [True: 0, False: 0] ------------------ 188| 0| if (mode == IGRAPH_ALL) { ------------------ | Branch (188:13): [True: 0, False: 0] ------------------ 189| 0| loops = IGRAPH_LOOPS_TWICE; 190| 0| } else { 191| 0| loops = IGRAPH_LOOPS_ONCE; 192| 0| } 193| 0| } 194| | 195| 11.8k| igraph_bool_t has_loops = false; 196| 11.8k| igraph_bool_t has_multiple = false; 197| 278k| for (igraph_integer_t i = 0; i < al->length; i++) { ------------------ | Branch (197:34): [True: 266k, False: 11.8k] ------------------ 198| 266k| IGRAPH_ALLOW_INTERRUPTION(); ------------------ | | 47| 266k| do { \ | | 48| 266k| if (igraph_i_interruption_handler) { \ | | ------------------ | | | Branch (48:13): [True: 0, False: 266k] | | ------------------ | | 49| 0| if (igraph_allow_interruption(NULL) != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (49:17): [True: 0, False: 0] | | ------------------ | | 50| 0| return IGRAPH_INTERRUPTED; \ | | 51| 0| } \ | | 52| 0| } \ | | 53| 266k| } while (0) | | ------------------ | | | Branch (53:14): [Folded - Ignored] | | ------------------ ------------------ 199| | 200| 266k| IGRAPH_CHECK(igraph_vector_int_init(&al->adjs[i], VECTOR(degrees)[i])); ------------------ | | 752| 266k| do { \ | | 753| 266k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 266k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 266k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 266k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 266k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 201| 266k| IGRAPH_CHECK(igraph_neighbors(graph, &al->adjs[i], i, mode)); ------------------ | | 752| 266k| do { \ | | 753| 266k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 266k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 266k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 266k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 266k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 202| | 203| | /* Attention: This function will only set values for has_loops and has_multiple 204| | * if it finds loops/multi-edges. Otherwise they are left at their original value. */ 205| 266k| IGRAPH_CHECK(igraph_i_simplify_sorted_int_adjacency_vector_in_place( ------------------ | | 752| 266k| do { \ | | 753| 266k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 266k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 266k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 266k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 266k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 206| 266k| &al->adjs[i], i, mode, loops, multiple, &has_loops, &has_multiple 207| 266k| )); 208| 266k| } 209| 11.8k| if (has_loops) { ------------------ | Branch (209:9): [True: 0, False: 11.8k] ------------------ 210| | /* If we have found at least one loop above, set the cache to true */ 211| 0| igraph_i_property_cache_set_bool(graph, IGRAPH_PROP_HAS_LOOP, true); 212| 11.8k| } else if (loops == IGRAPH_NO_LOOPS) { ------------------ | Branch (212:16): [True: 0, False: 11.8k] ------------------ 213| | /* If we explicitly _checked_ for loops (to remove them) and haven't 214| | * found one, set the cache to false. This is the only case when a 215| | * definite "no" from has_loops really means that there are no loops at 216| | * all */ 217| 0| igraph_i_property_cache_set_bool(graph, IGRAPH_PROP_HAS_LOOP, false); 218| 0| } 219| 11.8k| if (has_multiple) { ------------------ | Branch (219:9): [True: 0, False: 11.8k] ------------------ 220| | /* If we have found at least one multiedge above, set the cache to true */ 221| 0| igraph_i_property_cache_set_bool(graph, IGRAPH_PROP_HAS_MULTI, true); 222| 11.8k| } else if (multiple == IGRAPH_NO_MULTIPLE) { ------------------ | Branch (222:16): [True: 0, False: 11.8k] ------------------ 223| | /* If we explicitly _checked_ for multi-edges (to remove them) and 224| | * haven't found one, set the cache to false. This is the only case 225| | * when a definite "no" from has_multiple really means that there are 226| | * no multi-edges at all all */ 227| 0| igraph_i_property_cache_set_bool(graph, IGRAPH_PROP_HAS_MULTI, false); 228| 0| } 229| | 230| 11.8k| igraph_vector_int_destroy(°rees); 231| 11.8k| IGRAPH_FINALLY_CLEAN(2); /* + igraph_adjlist_destroy */ 232| | 233| 11.8k| return IGRAPH_SUCCESS; 234| 11.8k|} igraph_adjlist_destroy: 429| 11.8k|void igraph_adjlist_destroy(igraph_adjlist_t *al) { 430| 11.8k| igraph_integer_t i; 431| 278k| for (i = 0; i < al->length; i++) { ------------------ | Branch (431:17): [True: 266k, False: 11.8k] ------------------ 432| | /* This works if some igraph_vector_int_t's contain NULL, 433| | because igraph_vector_int_destroy can handle this. */ 434| 266k| igraph_vector_int_destroy(&al->adjs[i]); 435| 266k| } 436| 11.8k| IGRAPH_FREE(al->adjs); ------------------ | | 35| 11.8k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 437| 11.8k|} igraph_adjlist_size: 463| 115k|igraph_integer_t igraph_adjlist_size(const igraph_adjlist_t *al) { 464| 115k| return al->length; 465| 115k|} igraph_inclist_init: 751| 201| igraph_loops_t loops) { 752| 201| igraph_integer_t no_of_nodes = igraph_vcount(graph); 753| 201| igraph_vector_int_t degrees; 754| | 755| 201| if (mode != IGRAPH_IN && mode != IGRAPH_OUT && mode != IGRAPH_ALL) { ------------------ | Branch (755:9): [True: 201, False: 0] | Branch (755:30): [True: 201, False: 0] | Branch (755:52): [True: 0, False: 201] ------------------ 756| 0| IGRAPH_ERROR("Cannot create incidence list view.", IGRAPH_EINVMODE); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 757| 0| } 758| | 759| 201| if (!igraph_is_directed(graph)) { ------------------ | Branch (759:9): [True: 201, False: 0] ------------------ 760| 201| mode = IGRAPH_ALL; 761| 201| } 762| | 763| 201| IGRAPH_VECTOR_INT_INIT_FINALLY(°rees, no_of_nodes); ------------------ | | 124| 201| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 201| do { \ | | | | 753| 201| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 201| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 201| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 201] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 201| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 201| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 201| do { \ | | | | 696| 201| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 201| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 201| * incorrect destructor function with the pointer */ \ | | | | 699| 201| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 201| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 201| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 764| | /* igraph_degrees() is fast when loops=true */ 765| 201| IGRAPH_CHECK(igraph_degree(graph, °rees, igraph_vss_all(), mode, /* loops= */ 1)); ------------------ | | 752| 201| do { \ | | 753| 201| igraph_error_t igraph_i_ret = (expr); \ | | 754| 201| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 201| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 201] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 201| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 766| | 767| 201| il->length = no_of_nodes; 768| 201| il->incs = IGRAPH_CALLOC(il->length, igraph_vector_int_t); ------------------ | | 32| 201|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [True: 201, False: 0] | | ------------------ ------------------ 769| 201| if (il->incs == 0) { ------------------ | Branch (769:9): [True: 0, False: 201] ------------------ 770| 0| IGRAPH_ERROR("Cannot create incidence list view.", IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 771| 0| } 772| | 773| 201| IGRAPH_FINALLY(igraph_inclist_destroy, il); ------------------ | | 695| 201| do { \ | | 696| 201| /* the following branch makes the compiler check the compatibility of \ | | 697| 201| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 201| * incorrect destructor function with the pointer */ \ | | 699| 201| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 201| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 201| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 774| 1.44k| for (igraph_integer_t i = 0; i < il->length; i++) { ------------------ | Branch (774:34): [True: 1.24k, False: 201] ------------------ 775| 1.24k| IGRAPH_ALLOW_INTERRUPTION(); ------------------ | | 47| 1.24k| do { \ | | 48| 1.24k| if (igraph_i_interruption_handler) { \ | | ------------------ | | | Branch (48:13): [True: 0, False: 1.24k] | | ------------------ | | 49| 0| if (igraph_allow_interruption(NULL) != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (49:17): [True: 0, False: 0] | | ------------------ | | 50| 0| return IGRAPH_INTERRUPTED; \ | | 51| 0| } \ | | 52| 0| } \ | | 53| 1.24k| } while (0) | | ------------------ | | | Branch (53:14): [Folded - Ignored] | | ------------------ ------------------ 776| | 777| 1.24k| IGRAPH_CHECK(igraph_vector_int_init(&il->incs[i], VECTOR(degrees)[i])); ------------------ | | 752| 1.24k| do { \ | | 753| 1.24k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.24k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.24k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.24k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.24k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 778| 1.24k| IGRAPH_CHECK(igraph_incident(graph, &il->incs[i], i, mode)); ------------------ | | 752| 1.24k| do { \ | | 753| 1.24k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.24k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.24k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.24k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.24k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 779| | 780| 1.24k| if (loops != IGRAPH_LOOPS_TWICE) { ------------------ | Branch (780:13): [True: 0, False: 1.24k] ------------------ 781| 0| IGRAPH_CHECK( ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 782| 0| igraph_i_remove_loops_from_incidence_vector_in_place(&il->incs[i], graph, loops) 783| 0| ); 784| 0| } 785| 1.24k| } 786| | 787| 201| igraph_vector_int_destroy(°rees); 788| 201| IGRAPH_FINALLY_CLEAN(2); /* + igraph_inclist_destroy */ 789| | 790| 201| return IGRAPH_SUCCESS; 791| 201|} igraph_inclist_destroy: 835| 201|void igraph_inclist_destroy(igraph_inclist_t *il) { 836| 201| igraph_integer_t i; 837| 1.44k| for (i = 0; i < il->length; i++) { ------------------ | Branch (837:17): [True: 1.24k, False: 201] ------------------ 838| | /* This works if some igraph_vector_int_t's contain NULL, 839| | because igraph_vector_int_destroy can handle this. */ 840| 1.24k| igraph_vector_int_destroy(&il->incs[i]); 841| 1.24k| } 842| 201| IGRAPH_FREE(il->incs); ------------------ | | 35| 201|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 843| 201|} igraph_lazy_adjlist_init: 1059| 13.8k| igraph_multiple_t multiple) { 1060| 13.8k| if (mode != IGRAPH_IN && mode != IGRAPH_OUT && mode != IGRAPH_ALL) { ------------------ | Branch (1060:9): [True: 0, False: 13.8k] | Branch (1060:30): [True: 0, False: 0] | Branch (1060:52): [True: 0, False: 0] ------------------ 1061| 0| IGRAPH_ERROR("Cannot create lazy adjacency list view.", IGRAPH_EINVMODE); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1062| 0| } 1063| | 1064| 13.8k| if (!igraph_is_directed(graph)) { ------------------ | Branch (1064:9): [True: 0, False: 13.8k] ------------------ 1065| 0| mode = IGRAPH_ALL; 1066| 0| } 1067| | 1068| | /* if we already know there are no multi-edges, they don't need to be removed */ 1069| 13.8k| if (igraph_i_property_cache_has(graph, IGRAPH_PROP_HAS_MULTI) && ------------------ | Branch (1069:9): [True: 13.8k, False: 0] ------------------ 1070| 13.8k| !igraph_i_property_cache_get_bool(graph, IGRAPH_PROP_HAS_MULTI)) { ------------------ | Branch (1070:9): [True: 13.8k, False: 0] ------------------ 1071| 13.8k| multiple = IGRAPH_MULTIPLE; 1072| 13.8k| } 1073| | 1074| | /* if we already know there are no loops, they don't need to be removed */ 1075| 13.8k| if (igraph_i_property_cache_has(graph, IGRAPH_PROP_HAS_LOOP) && ------------------ | Branch (1075:9): [True: 13.8k, False: 0] ------------------ 1076| 13.8k| !igraph_i_property_cache_get_bool(graph, IGRAPH_PROP_HAS_LOOP)) { ------------------ | Branch (1076:9): [True: 13.8k, False: 0] ------------------ 1077| 13.8k| if (mode == IGRAPH_ALL) { ------------------ | Branch (1077:13): [True: 0, False: 13.8k] ------------------ 1078| 0| loops = IGRAPH_LOOPS_TWICE; 1079| 13.8k| } else { 1080| 13.8k| loops = IGRAPH_LOOPS_ONCE; 1081| 13.8k| } 1082| 13.8k| } 1083| | 1084| 13.8k| al->mode = mode; 1085| 13.8k| al->loops = loops; 1086| 13.8k| al->multiple = multiple; 1087| 13.8k| al->graph = graph; 1088| | 1089| 13.8k| al->length = igraph_vcount(graph); 1090| 13.8k| al->adjs = IGRAPH_CALLOC(al->length, igraph_vector_int_t*); ------------------ | | 32| 13.8k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [True: 13.8k, False: 0] | | ------------------ ------------------ 1091| 13.8k| IGRAPH_CHECK_OOM(al->adjs, "Insufficient memory for creating lazy adjacency list view."); ------------------ | | 807| 13.8k| do { \ | | 808| 13.8k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 13.8k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 1092| | 1093| 13.8k| return IGRAPH_SUCCESS; 1094| 13.8k|} igraph_lazy_adjlist_destroy: 1106| 13.8k|void igraph_lazy_adjlist_destroy(igraph_lazy_adjlist_t *al) { 1107| 13.8k| igraph_lazy_adjlist_clear(al); 1108| 13.8k| IGRAPH_FREE(al->adjs); ------------------ | | 35| 13.8k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 1109| 13.8k|} igraph_lazy_adjlist_clear: 1119| 13.8k|void igraph_lazy_adjlist_clear(igraph_lazy_adjlist_t *al) { 1120| 13.8k| igraph_integer_t i, n = al->length; 1121| 111k| for (i = 0; i < n; i++) { ------------------ | Branch (1121:17): [True: 97.5k, False: 13.8k] ------------------ 1122| 97.5k| if (al->adjs[i] != 0) { ------------------ | Branch (1122:13): [True: 15.2k, False: 82.2k] ------------------ 1123| 15.2k| igraph_vector_int_destroy(al->adjs[i]); 1124| 15.2k| IGRAPH_FREE(al->adjs[i]); ------------------ | | 35| 15.2k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 1125| 15.2k| } 1126| 97.5k| } 1127| 13.8k|} igraph_i_lazy_adjlist_get_real: 1142| 15.2k|igraph_vector_int_t *igraph_i_lazy_adjlist_get_real(igraph_lazy_adjlist_t *al, igraph_integer_t no) { 1143| 15.2k| igraph_error_t ret; 1144| | 1145| 15.2k| if (al->adjs[no] == NULL) { ------------------ | Branch (1145:9): [True: 15.2k, False: 0] ------------------ 1146| 15.2k| al->adjs[no] = IGRAPH_CALLOC(1, igraph_vector_int_t); ------------------ | | 32| 15.2k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 1147| 15.2k| if (al->adjs[no] == NULL) { ------------------ | Branch (1147:13): [True: 0, False: 15.2k] ------------------ 1148| 0| return NULL; 1149| 0| } 1150| | 1151| 15.2k| ret = igraph_vector_int_init(al->adjs[no], 0); 1152| 15.2k| if (ret != IGRAPH_SUCCESS) { ------------------ | Branch (1152:13): [True: 0, False: 15.2k] ------------------ 1153| 0| IGRAPH_FREE(al->adjs[no]); ------------------ | | 35| 0|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 1154| 0| return NULL; 1155| 0| } 1156| | 1157| 15.2k| ret = igraph_neighbors(al->graph, al->adjs[no], no, al->mode); 1158| 15.2k| if (ret != IGRAPH_SUCCESS) { ------------------ | Branch (1158:13): [True: 0, False: 15.2k] ------------------ 1159| 0| igraph_vector_int_destroy(al->adjs[no]); 1160| 0| IGRAPH_FREE(al->adjs[no]); ------------------ | | 35| 0|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 1161| 0| return NULL; 1162| 0| } 1163| | 1164| 15.2k| ret = igraph_i_simplify_sorted_int_adjacency_vector_in_place( 1165| 15.2k| al->adjs[no], no, al->mode, al->loops, al->multiple, NULL, 1166| 15.2k| NULL 1167| 15.2k| ); 1168| 15.2k| if (ret != IGRAPH_SUCCESS) { ------------------ | Branch (1168:13): [True: 0, False: 15.2k] ------------------ 1169| 0| igraph_vector_int_destroy(al->adjs[no]); 1170| 0| IGRAPH_FREE(al->adjs[no]); ------------------ | | 35| 0|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 1171| 0| return NULL; 1172| 0| } 1173| 15.2k| } 1174| | 1175| 15.2k| return al->adjs[no]; 1176| 15.2k|} adjlist.c:igraph_i_simplify_sorted_int_adjacency_vector_in_place: 880| 282k|) { 881| 282k| igraph_bool_t dummy1, dummy2; 882| 282k| if (has_loops == NULL) { ------------------ | Branch (882:9): [True: 15.2k, False: 266k] ------------------ 883| 15.2k| has_loops = &dummy1; 884| 15.2k| } 885| 282k| if (has_multiple == NULL) { ------------------ | Branch (885:9): [True: 15.2k, False: 266k] ------------------ 886| 15.2k| has_multiple = &dummy2; 887| 15.2k| } 888| 282k| igraph_integer_t i, p = 0; 889| 282k| igraph_integer_t n = igraph_vector_int_size(v); 890| | 891| 282k| if ( 892| 282k| multiple == IGRAPH_MULTIPLE && ------------------ | Branch (892:9): [True: 282k, False: 0] ------------------ 893| 282k| ( 894| 282k| loops == IGRAPH_LOOPS_TWICE || ------------------ | Branch (894:13): [True: 11.4k, False: 270k] ------------------ 895| 282k| (loops == IGRAPH_LOOPS_ONCE && (mode == IGRAPH_IN || mode == IGRAPH_OUT)) ------------------ | Branch (895:14): [True: 270k, False: 0] | Branch (895:45): [True: 143k, False: 127k] | Branch (895:66): [True: 127k, False: 0] ------------------ 896| 282k| ) 897| 282k| ) { 898| | /* nothing to simplify */ 899| 282k| return IGRAPH_SUCCESS; 900| 282k| } 901| | 902| 0| if (loops == IGRAPH_NO_LOOPS) { ------------------ | Branch (902:9): [True: 0, False: 0] ------------------ 903| 0| if (multiple == IGRAPH_NO_MULTIPLE) { ------------------ | Branch (903:13): [True: 0, False: 0] ------------------ 904| | /* We need to get rid of loops and multiple edges completely */ 905| 0| for (i = 0; i < n; i++) { ------------------ | Branch (905:25): [True: 0, False: 0] ------------------ 906| 0| if (VECTOR(*v)[i] != index && ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (906:21): [True: 0, False: 0] ------------------ 907| 0| (i == n - 1 || VECTOR(*v)[i + 1] != VECTOR(*v)[i])) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ (i == n - 1 || VECTOR(*v)[i + 1] != VECTOR(*v)[i])) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (907:22): [True: 0, False: 0] | Branch (907:36): [True: 0, False: 0] ------------------ 908| 0| VECTOR(*v)[p] = VECTOR(*v)[i]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*v)[p] = VECTOR(*v)[i]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 909| 0| p++; 910| 0| } else { 911| 0| if (VECTOR(*v)[i] == index) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (911:25): [True: 0, False: 0] ------------------ 912| 0| *has_loops = true; 913| 0| } else if (i != n - 1 && VECTOR(*v)[i + 1] == VECTOR(*v)[i]) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ } else if (i != n - 1 && VECTOR(*v)[i + 1] == VECTOR(*v)[i]) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (913:32): [True: 0, False: 0] | Branch (913:46): [True: 0, False: 0] ------------------ 914| 0| *has_multiple = true; 915| 0| } 916| 0| } 917| 0| } 918| 0| } else { 919| | /* We need to get rid of loops but keep multiple edges */ 920| 0| for (i = 0; i < n; i++) { ------------------ | Branch (920:25): [True: 0, False: 0] ------------------ 921| 0| if (VECTOR(*v)[i] != index) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (921:21): [True: 0, False: 0] ------------------ 922| 0| VECTOR(*v)[p] = VECTOR(*v)[i]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*v)[p] = VECTOR(*v)[i]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 923| 0| p++; 924| 0| } else { 925| 0| *has_loops = true; 926| 0| } 927| 0| } 928| 0| } 929| 0| } else if (loops == IGRAPH_LOOPS_ONCE) { ------------------ | Branch (929:16): [True: 0, False: 0] ------------------ 930| 0| if (multiple == IGRAPH_NO_MULTIPLE) { ------------------ | Branch (930:13): [True: 0, False: 0] ------------------ 931| | /* We need to get rid of multiple edges completely (including 932| | * multiple loop edges), but keep one edge from each loop edge */ 933| 0| for (i = 0; i < n; i++) { ------------------ | Branch (933:25): [True: 0, False: 0] ------------------ 934| 0| if (i == n - 1 || VECTOR(*v)[i + 1] != VECTOR(*v)[i]) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ if (i == n - 1 || VECTOR(*v)[i + 1] != VECTOR(*v)[i]) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (934:21): [True: 0, False: 0] | Branch (934:35): [True: 0, False: 0] ------------------ 935| 0| VECTOR(*v)[p] = VECTOR(*v)[i]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*v)[p] = VECTOR(*v)[i]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 936| 0| p++; 937| 0| } else if ( 938| | /* If this is not a loop then we have a multigraph. 939| | Else we have at least two loops. 940| | The v vector comes from a call to igraph_neighbors. 941| | This will count loops twice if mode == IGRAPH_ALL. 942| | So if mode != IGRAPH_ALL, 943| | then we have a multigraph. 944| | If mode == IGRAPH_ALL and we have three loops 945| | then we also have a multigraph 946| | */ 947| 0| (VECTOR(*v)[i] != index) || ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (947:25): [True: 0, False: 0] ------------------ 948| 0| (mode != IGRAPH_ALL) || ------------------ | Branch (948:24): [True: 0, False: 0] ------------------ 949| 0| (mode == IGRAPH_ALL && i < n - 2 && VECTOR(*v)[i + 2] == VECTOR(*v)[i]) ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ (mode == IGRAPH_ALL && i < n - 2 && VECTOR(*v)[i + 2] == VECTOR(*v)[i]) ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (949:25): [True: 0, False: 0] | Branch (949:47): [True: 0, False: 0] | Branch (949:60): [True: 0, False: 0] ------------------ 950| 0| ){ 951| 0| *has_multiple = true; 952| 0| } 953| 0| } 954| 0| } else { 955| | /* We need to keep one edge from each loop edge and we don't need to 956| | * touch multiple edges. Note that we can get here only if 957| | * mode == IGRAPH_ALL; if mode was IGRAPH_IN or IGRAPH_OUT, we would 958| | * have bailed out earlier */ 959| 0| for (i = 0; i < n; i++) { ------------------ | Branch (959:25): [True: 0, False: 0] ------------------ 960| 0| VECTOR(*v)[p] = VECTOR(*v)[i]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*v)[p] = VECTOR(*v)[i]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 961| 0| if (VECTOR(*v)[i] == index) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (961:21): [True: 0, False: 0] ------------------ 962| 0| *has_loops = true; 963| | /* this was a loop edge so if the next element is the same, we 964| | * need to skip that */ 965| 0| if (i < n-1 && VECTOR(*v)[i + 1] == index) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (965:25): [True: 0, False: 0] | Branch (965:36): [True: 0, False: 0] ------------------ 966| 0| i++; 967| 0| } 968| 0| } 969| 0| p++; 970| 0| } 971| 0| } 972| 0| } else if (loops == IGRAPH_LOOPS_TWICE && multiple == IGRAPH_NO_MULTIPLE) { ------------------ | Branch (972:16): [True: 0, False: 0] | Branch (972:47): [True: 0, False: 0] ------------------ 973| | /* We need to get rid of multiple edges completely (including 974| | * multiple loop edges), but keep both edge from each loop edge */ 975| 0| for (i = 0; i < n; i++) { ------------------ | Branch (975:21): [True: 0, False: 0] ------------------ 976| 0| if (i == n - 1 || VECTOR(*v)[i + 1] != VECTOR(*v)[i]) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ if (i == n - 1 || VECTOR(*v)[i + 1] != VECTOR(*v)[i]) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (976:17): [True: 0, False: 0] | Branch (976:31): [True: 0, False: 0] ------------------ 977| 0| VECTOR(*v)[p] = VECTOR(*v)[i]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*v)[p] = VECTOR(*v)[i]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 978| 0| p++; 979| 0| } else { 980| 0| *has_multiple = 1; 981| | /* Current item is the same as the next one, but if it is a 982| | * loop edge, then the first one or two items are okay. We need 983| | * to keep one if mode == IGRAPH_IN or mode == IGRAPH_OUT, 984| | * otherwise we need to keep two */ 985| 0| if (VECTOR(*v)[i] == index) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (985:21): [True: 0, False: 0] ------------------ 986| 0| VECTOR(*v)[p] = VECTOR(*v)[i]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*v)[p] = VECTOR(*v)[i]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 987| 0| p++; 988| 0| if (mode == IGRAPH_ALL) { ------------------ | Branch (988:25): [True: 0, False: 0] ------------------ 989| 0| VECTOR(*v)[p] = VECTOR(*v)[i]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*v)[p] = VECTOR(*v)[i]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 990| 0| p++; 991| 0| } 992| | /* skip over all the items corresponding to the loop edges */ 993| 0| while (i < n && VECTOR(*v)[i] == index) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (993:28): [True: 0, False: 0] | Branch (993:37): [True: 0, False: 0] ------------------ 994| 0| i++; 995| 0| } 996| 0| i--; /* because the for loop also increases i by 1 */ 997| 0| } 998| 0| } 999| 0| } 1000| 0| } else { 1001| | /* TODO; we don't use this combination yet */ 1002| 0| return IGRAPH_UNIMPLEMENTED; 1003| 0| } 1004| | 1005| | /* always succeeds since we are never growing the vector */ 1006| 0| igraph_vector_int_resize(v, p); 1007| | 1008| 0| return IGRAPH_SUCCESS; 1009| 0|} igraph_i_attribute_init: 37| 42.7k|igraph_error_t igraph_i_attribute_init(igraph_t *graph, void *attr) { 38| 42.7k| graph->attr = 0; 39| 42.7k| if (igraph_i_attribute_table) { ------------------ | Branch (39:9): [True: 0, False: 42.7k] ------------------ 40| 0| return igraph_i_attribute_table->init(graph, attr); 41| 42.7k| } else { 42| 42.7k| return IGRAPH_SUCCESS; 43| 42.7k| } 44| 42.7k|} igraph_i_attribute_copy: 53| 8.01k| igraph_bool_t va, igraph_bool_t ea) { 54| 8.01k| if (igraph_i_attribute_table) { ------------------ | Branch (54:9): [True: 0, False: 8.01k] ------------------ 55| 0| return igraph_i_attribute_table->copy(to, from, ga, va, ea); 56| 8.01k| } else { 57| 8.01k| return IGRAPH_SUCCESS; 58| 8.01k| } 59| 8.01k|} igraph_i_attribute_permute_vertices: 71| 8.01k| const igraph_vector_int_t *idx) { 72| | /* graph and newgraph may be the same, in which case we need to support 73| | * in-place operations. If they are _not_ the same, it is assumed that the 74| | * new graph has no vertex attributes yet */ 75| 8.01k| if (igraph_i_attribute_table) { ------------------ | Branch (75:9): [True: 0, False: 8.01k] ------------------ 76| 0| return igraph_i_attribute_table->permute_vertices(graph, newgraph, idx); 77| 8.01k| } else { 78| 8.01k| return IGRAPH_SUCCESS; 79| 8.01k| } 80| 8.01k|} igraph_i_attribute_permute_edges: 110| 8.85k| const igraph_vector_int_t *idx) { 111| | /* graph and newgraph may be the same, in which case we need to support 112| | * in-place operations. If they are _not_ the same, it is assumed that the 113| | * new graph has no edge attributes yet */ 114| 8.85k| if (igraph_i_attribute_table) { ------------------ | Branch (114:9): [True: 0, False: 8.85k] ------------------ 115| 0| return igraph_i_attribute_table->permute_edges(graph, newgraph, idx); 116| 8.85k| } else { 117| 8.85k| return IGRAPH_SUCCESS; 118| 8.85k| } 119| 8.85k|} igraph_are_connected: 49| 58.4k| igraph_bool_t *res) { 50| | 51| 58.4k| igraph_integer_t nov = igraph_vcount(graph); 52| 58.4k| igraph_integer_t eid = -1; 53| | 54| 58.4k| if (v1 < 0 || v2 < 0 || v1 > nov - 1 || v2 > nov - 1) { ------------------ | Branch (54:9): [True: 0, False: 58.4k] | Branch (54:19): [True: 0, False: 58.4k] | Branch (54:29): [True: 0, False: 58.4k] | Branch (54:45): [True: 0, False: 58.4k] ------------------ 55| 0| IGRAPH_ERROR("Invalid vertex ID when checking if two vertices are connected.", IGRAPH_EINVVID); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 56| 0| } 57| | 58| 58.4k| igraph_get_eid(graph, &eid, v1, v2, IGRAPH_DIRECTED, /*error=*/ false); 59| 58.4k| *res = (eid >= 0); 60| | 61| 58.4k| return IGRAPH_SUCCESS; 62| 58.4k|} igraph_i_property_cache_init: 30| 67.8k|igraph_error_t igraph_i_property_cache_init(igraph_i_property_cache_t *cache) { 31| 67.8k| IGRAPH_STATIC_ASSERT(IGRAPH_PROP_I_SIZE <= 32); ------------------ | | 64| 67.8k|#define IGRAPH_STATIC_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)])) ------------------ 32| | 33| 67.8k| memset(cache->value, 0, sizeof(cache->value) / sizeof(cache->value[0])); 34| 67.8k| cache->known = 0; 35| 67.8k| return IGRAPH_SUCCESS; 36| 67.8k|} igraph_i_property_cache_copy: 43| 26.6k| const igraph_i_property_cache_t *other_cache) { 44| 26.6k| *cache = *other_cache; 45| 26.6k| return IGRAPH_SUCCESS; 46| 26.6k|} igraph_i_property_cache_destroy: 51| 94.4k|void igraph_i_property_cache_destroy(igraph_i_property_cache_t *cache) { 52| 94.4k| IGRAPH_UNUSED(cache); ------------------ | | 12| 94.4k|#define IGRAPH_UNUSED(x) (void)(x) ------------------ 53| | /* Nothing to do */ 54| 94.4k|} igraph_i_property_cache_get_bool: 70| 29.1k|igraph_bool_t igraph_i_property_cache_get_bool(const igraph_t *graph, igraph_cached_property_t prop) { 71| 29.1k| IGRAPH_ASSERT(prop >= 0 && prop < IGRAPH_PROP_I_SIZE); ------------------ | | 1107| 29.1k| do { \ | | 1108| 29.1k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 58.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 29.1k] | | | | | Branch (708:50): [True: 29.1k, False: 0] | | | | | Branch (708:50): [True: 29.1k, False: 0] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 29.1k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 72| 29.1k| assert(graph->cache != NULL); 73| 29.1k| return graph->cache->value[prop]; 74| 29.1k|} igraph_i_property_cache_has: 82| 79.2k|igraph_bool_t igraph_i_property_cache_has(const igraph_t *graph, igraph_cached_property_t prop) { 83| 79.2k| IGRAPH_ASSERT(prop >= 0 && prop < IGRAPH_PROP_I_SIZE); ------------------ | | 1107| 79.2k| do { \ | | 1108| 79.2k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 158k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 79.2k] | | | | | Branch (708:50): [True: 79.2k, False: 0] | | | | | Branch (708:50): [True: 79.2k, False: 0] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 79.2k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 84| 79.2k| assert(graph->cache != NULL); 85| 79.2k| return graph->cache->known & (1 << prop); 86| 79.2k|} igraph_i_property_cache_set_bool: 95| 33.0k|void igraph_i_property_cache_set_bool(const igraph_t *graph, igraph_cached_property_t prop, igraph_bool_t value) { 96| 33.0k| IGRAPH_ASSERT(prop >= 0 && prop < IGRAPH_PROP_I_SIZE); ------------------ | | 1107| 33.0k| do { \ | | 1108| 33.0k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 66.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 33.0k] | | | | | Branch (708:50): [True: 33.0k, False: 0] | | | | | Branch (708:50): [True: 33.0k, False: 0] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 33.0k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 97| 33.0k| assert(graph->cache != NULL); 98| | /* Even though graph is const, updating the cache is not considered modification. 99| | * Functions that merely compute graph properties, and thus leave the graph structure 100| | * intact, will often update the cache. */ 101| 33.0k| graph->cache->value[prop] = value; 102| 33.0k| graph->cache->known |= (1 << prop); 103| 33.0k|} igraph_i_property_cache_invalidate_conditionally: 151| 137k|) { 152| 137k| uint32_t invalidate = ~keep_always; 153| 137k| uint32_t mask; 154| 137k| uint32_t maybe_keep; 155| 137k| igraph_bool_t cached_value; 156| | 157| 137k| assert(graph->cache != NULL); 158| | 159| | /* The bits of maybe_keep are set to 1 for those properties that are: 160| | * 161| | * - currently cached 162| | * - should _probably_ be invalidated 163| | * - _but_ the current cached value of the property may change the decision 164| | */ 165| 137k| maybe_keep = graph->cache->known & invalidate & (keep_when_false | keep_when_true); 166| | 167| 137k| if (maybe_keep) { ------------------ | Branch (167:9): [True: 683, False: 137k] ------------------ 168| 5.46k| for (igraph_cached_property_t prop = (igraph_cached_property_t ) 0; prop < IGRAPH_PROP_I_SIZE; ++prop) { ------------------ | Branch (168:77): [True: 4.78k, False: 683] ------------------ 169| 4.78k| mask = 1 << prop; 170| 4.78k| if (maybe_keep & mask) { ------------------ | Branch (170:17): [True: 1.36k, False: 3.41k] ------------------ 171| | /* if we get here, we know that the property is cached; we have 172| | * masked maybe_keep with graph->cache->known */ 173| 1.36k| cached_value = igraph_i_property_cache_get_bool(graph, prop); 174| 1.36k| if ( 175| 1.36k| ((keep_when_false & mask) && !cached_value) || ------------------ | Branch (175:22): [True: 0, False: 1.36k] | Branch (175:50): [True: 0, False: 0] ------------------ 176| 1.36k| ((keep_when_true & mask) && cached_value) ------------------ | Branch (176:22): [True: 1.36k, False: 0] | Branch (176:49): [True: 0, False: 1.36k] ------------------ 177| 1.36k| ) { 178| 0| invalidate &= ~mask; 179| 0| } 180| 1.36k| } 181| 4.78k| } 182| 683| } 183| | 184| 137k| graph->cache->known &= ~invalidate; 185| 137k|} igraph_vss_all: 116| 61.2k|igraph_vs_t igraph_vss_all(void) { 117| 61.2k| igraph_vs_t allvs; 118| 61.2k| allvs.type = IGRAPH_VS_ALL; 119| 61.2k| return allvs; 120| 61.2k|} igraph_vss_vector: 328| 58.9k|igraph_vs_t igraph_vss_vector(const igraph_vector_int_t *v) { 329| 58.9k| igraph_vs_t vecvs; 330| 58.9k| vecvs.type = IGRAPH_VS_VECTORPTR; 331| 58.9k| vecvs.data.vecptr = v; 332| 58.9k| return vecvs; 333| 58.9k|} igraph_vs_is_all: 574| 33.1k|igraph_bool_t igraph_vs_is_all(const igraph_vs_t *vs) { 575| 33.1k| return vs->type == IGRAPH_VS_ALL; 576| 33.1k|} igraph_vs_size: 638| 33.1k| igraph_integer_t *result) { 639| 33.1k| igraph_vector_int_t vec; 640| 33.1k| igraph_bool_t *seen; 641| 33.1k| igraph_integer_t i; 642| 33.1k| igraph_integer_t vec_len; 643| | 644| 33.1k| switch (vs->type) { ------------------ | Branch (644:13): [True: 0, False: 33.1k] ------------------ 645| 0| case IGRAPH_VS_NONE: ------------------ | Branch (645:5): [True: 0, False: 33.1k] ------------------ 646| 0| *result = 0; return IGRAPH_SUCCESS; 647| | 648| 0| case IGRAPH_VS_1: ------------------ | Branch (648:5): [True: 0, False: 33.1k] ------------------ 649| 0| *result = 0; 650| 0| if (vs->data.vid < igraph_vcount(graph) && vs->data.vid >= 0) { ------------------ | Branch (650:13): [True: 0, False: 0] | Branch (650:52): [True: 0, False: 0] ------------------ 651| 0| *result = 1; 652| 0| } 653| 0| return IGRAPH_SUCCESS; 654| | 655| 0| case IGRAPH_VS_RANGE: ------------------ | Branch (655:5): [True: 0, False: 33.1k] ------------------ 656| 0| *result = vs->data.range.end - vs->data.range.start; 657| 0| return IGRAPH_SUCCESS; 658| | 659| 0| case IGRAPH_VS_ALL: ------------------ | Branch (659:5): [True: 0, False: 33.1k] ------------------ 660| 0| *result = igraph_vcount(graph); return IGRAPH_SUCCESS; 661| | 662| 0| case IGRAPH_VS_ADJ: ------------------ | Branch (662:5): [True: 0, False: 33.1k] ------------------ 663| 0| IGRAPH_VECTOR_INT_INIT_FINALLY(&vec, 0); ------------------ | | 124| 0| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 0| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 0| do { \ | | | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 0| * incorrect destructor function with the pointer */ \ | | | | 699| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 0| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 664| 0| IGRAPH_CHECK(igraph_neighbors(graph, &vec, vs->data.adj.vid, vs->data.adj.mode)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 665| 0| *result = igraph_vector_int_size(&vec); 666| 0| igraph_vector_int_destroy(&vec); 667| 0| IGRAPH_FINALLY_CLEAN(1); 668| 0| return IGRAPH_SUCCESS; 669| | 670| 0| case IGRAPH_VS_NONADJ: ------------------ | Branch (670:5): [True: 0, False: 33.1k] ------------------ 671| 0| IGRAPH_VECTOR_INT_INIT_FINALLY(&vec, 0); ------------------ | | 124| 0| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 0| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 0| do { \ | | | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 0| * incorrect destructor function with the pointer */ \ | | | | 699| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 0| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 672| 0| IGRAPH_CHECK(igraph_neighbors(graph, &vec, vs->data.adj.vid, vs->data.adj.mode)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 673| 0| vec_len = igraph_vector_int_size(&vec); 674| 0| *result = igraph_vcount(graph); 675| 0| seen = IGRAPH_CALLOC(*result, igraph_bool_t); ------------------ | | 32| 0|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [True: 0, False: 0] | | ------------------ ------------------ 676| 0| IGRAPH_CHECK_OOM(seen, "Cannot calculate vertex selector length."); ------------------ | | 807| 0| do { \ | | 808| 0| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 0| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 677| 0| IGRAPH_FINALLY(igraph_free, seen); ------------------ | | 695| 0| do { \ | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 0| * incorrect destructor function with the pointer */ \ | | 699| 0| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 0| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 678| 0| for (i = 0; i < vec_len; i++) { ------------------ | Branch (678:21): [True: 0, False: 0] ------------------ 679| 0| if (!seen[ VECTOR(vec)[i] ]) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (679:17): [True: 0, False: 0] ------------------ 680| 0| (*result)--; 681| 0| seen[ VECTOR(vec)[i] ] = 1; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 682| 0| } 683| 0| } 684| 0| igraph_free(seen); 685| 0| igraph_vector_int_destroy(&vec); 686| 0| IGRAPH_FINALLY_CLEAN(2); 687| 0| return IGRAPH_SUCCESS; 688| | 689| 0| case IGRAPH_VS_VECTOR: ------------------ | Branch (689:5): [True: 0, False: 33.1k] ------------------ 690| 33.1k| case IGRAPH_VS_VECTORPTR: ------------------ | Branch (690:5): [True: 33.1k, False: 0] ------------------ 691| 33.1k| *result = igraph_vector_int_size(vs->data.vecptr); 692| 33.1k| return IGRAPH_SUCCESS; 693| 33.1k| } 694| | 695| 0| IGRAPH_ERROR("Cannot calculate selector length, invalid selector type", ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 696| 0| IGRAPH_EINVAL); 697| 0|} igraph_vit_create: 733| 120k|igraph_error_t igraph_vit_create(const igraph_t *graph, igraph_vs_t vs, igraph_vit_t *vit) { 734| 120k| igraph_vector_int_t vec; 735| 120k| igraph_vector_int_t *vec_int; 736| 120k| igraph_bool_t *seen; 737| 120k| igraph_integer_t i, j, n; 738| 120k| igraph_integer_t vec_len; 739| | 740| 120k| switch (vs.type) { 741| 61.2k| case IGRAPH_VS_ALL: ------------------ | Branch (741:5): [True: 61.2k, False: 58.9k] ------------------ 742| 61.2k| vit->type = IGRAPH_VIT_RANGE; 743| 61.2k| vit->pos = 0; 744| 61.2k| vit->start = 0; 745| 61.2k| vit->end = igraph_vcount(graph); 746| 61.2k| break; 747| 0| case IGRAPH_VS_ADJ: ------------------ | Branch (747:5): [True: 0, False: 120k] ------------------ 748| 0| vec_int = IGRAPH_CALLOC(1, igraph_vector_int_t); ------------------ | | 32| 0|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 749| 0| IGRAPH_CHECK_OOM(vec_int, "Cannot create vertex iterator."); ------------------ | | 807| 0| do { \ | | 808| 0| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 0| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 750| 0| IGRAPH_FINALLY(igraph_free, vec_int); ------------------ | | 695| 0| do { \ | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 0| * incorrect destructor function with the pointer */ \ | | 699| 0| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 0| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 751| 0| IGRAPH_VECTOR_INT_INIT_FINALLY(vec_int, 0); ------------------ | | 124| 0| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 0| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 0| do { \ | | | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 0| * incorrect destructor function with the pointer */ \ | | | | 699| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 0| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 752| 0| IGRAPH_VECTOR_INT_INIT_FINALLY(&vec, 0); ------------------ | | 124| 0| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 0| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 0| do { \ | | | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 0| * incorrect destructor function with the pointer */ \ | | | | 699| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 0| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 753| 0| IGRAPH_CHECK(igraph_neighbors(graph, &vec, vs.data.adj.vid, vs.data.adj.mode)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 754| 0| n = igraph_vector_int_size(&vec); 755| 0| IGRAPH_CHECK(igraph_vector_int_resize(vec_int, n)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 756| 0| for (i = 0; i < n; i++) { ------------------ | Branch (756:21): [True: 0, False: 0] ------------------ 757| 0| VECTOR(*vec_int)[i] = VECTOR(vec)[i]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*vec_int)[i] = VECTOR(vec)[i]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 758| 0| } 759| | 760| 0| igraph_vector_int_destroy(&vec); 761| 0| IGRAPH_FINALLY_CLEAN(3); 762| | 763| 0| vit->type = IGRAPH_VIT_VECTOR; 764| 0| vit->pos = 0; 765| 0| vit->start = 0; 766| 0| vit->vec = vec_int; 767| 0| vit->end = n; 768| | 769| 0| break; 770| 0| case IGRAPH_VS_NONADJ: ------------------ | Branch (770:5): [True: 0, False: 120k] ------------------ 771| 0| vec_int = IGRAPH_CALLOC(1, igraph_vector_int_t); ------------------ | | 32| 0|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 772| 0| IGRAPH_CHECK_OOM(vec_int, "Cannot create vertex iterator."); ------------------ | | 807| 0| do { \ | | 808| 0| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 0| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 773| 0| IGRAPH_FINALLY(igraph_free, vec_int); ------------------ | | 695| 0| do { \ | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 0| * incorrect destructor function with the pointer */ \ | | 699| 0| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 0| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 774| 0| IGRAPH_VECTOR_INT_INIT_FINALLY(vec_int, 0); ------------------ | | 124| 0| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 0| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 0| do { \ | | | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 0| * incorrect destructor function with the pointer */ \ | | | | 699| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 0| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 775| 0| IGRAPH_VECTOR_INT_INIT_FINALLY(&vec, 0); ------------------ | | 124| 0| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 0| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 0| do { \ | | | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 0| * incorrect destructor function with the pointer */ \ | | | | 699| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 0| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 776| 0| IGRAPH_CHECK(igraph_neighbors(graph, &vec, vs.data.adj.vid, vs.data.adj.mode)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 777| 0| vec_len = igraph_vector_int_size(&vec); 778| 0| n = igraph_vcount(graph); 779| 0| seen = IGRAPH_CALLOC(n, igraph_bool_t); ------------------ | | 32| 0|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [True: 0, False: 0] | | ------------------ ------------------ 780| 0| IGRAPH_CHECK_OOM(seen, "Cannot create vertex iterator."); ------------------ | | 807| 0| do { \ | | 808| 0| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 0| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 781| 0| IGRAPH_FINALLY(igraph_free, seen); ------------------ | | 695| 0| do { \ | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 0| * incorrect destructor function with the pointer */ \ | | 699| 0| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 0| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 782| 0| for (i = 0; i < vec_len; i++) { ------------------ | Branch (782:21): [True: 0, False: 0] ------------------ 783| 0| if (! seen [ VECTOR(vec)[i] ] ) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (783:17): [True: 0, False: 0] ------------------ 784| 0| n--; 785| 0| seen[ VECTOR(vec)[i] ] = 1; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 786| 0| } 787| 0| } 788| 0| IGRAPH_CHECK(igraph_vector_int_resize(vec_int, n)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 789| 0| for (i = 0, j = 0; j < n; i++) { ------------------ | Branch (789:28): [True: 0, False: 0] ------------------ 790| 0| if (!seen[i]) { ------------------ | Branch (790:17): [True: 0, False: 0] ------------------ 791| 0| VECTOR(*vec_int)[j++] = i; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 792| 0| } 793| 0| } 794| | 795| 0| IGRAPH_FREE(seen); ------------------ | | 35| 0|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 796| 0| igraph_vector_int_destroy(&vec); 797| 0| IGRAPH_FINALLY_CLEAN(4); 798| | 799| 0| vit->type = IGRAPH_VIT_VECTOR; 800| 0| vit->pos = 0; 801| 0| vit->start = 0; 802| 0| vit->vec = vec_int; 803| 0| vit->end = n; 804| 0| break; 805| 0| case IGRAPH_VS_NONE: ------------------ | Branch (805:5): [True: 0, False: 120k] ------------------ 806| 0| vit->type = IGRAPH_VIT_RANGE; 807| 0| vit->pos = 0; 808| 0| vit->start = 0; 809| 0| vit->end = 0; 810| 0| break; 811| 0| case IGRAPH_VS_1: ------------------ | Branch (811:5): [True: 0, False: 120k] ------------------ 812| 0| vit->type = IGRAPH_VIT_RANGE; 813| 0| vit->pos = vs.data.vid; 814| 0| vit->start = vs.data.vid; 815| 0| vit->end = vs.data.vid + 1; 816| 0| if (vit->pos >= igraph_vcount(graph)) { ------------------ | Branch (816:13): [True: 0, False: 0] ------------------ 817| 0| IGRAPH_ERROR("Cannot create iterator, invalid vertex ID.", IGRAPH_EINVVID); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 818| 0| } 819| 0| break; 820| 58.9k| case IGRAPH_VS_VECTORPTR: ------------------ | Branch (820:5): [True: 58.9k, False: 61.2k] ------------------ 821| 58.9k| case IGRAPH_VS_VECTOR: ------------------ | Branch (821:5): [True: 0, False: 120k] ------------------ 822| 58.9k| vit->type = IGRAPH_VIT_VECTORPTR; 823| 58.9k| vit->pos = 0; 824| 58.9k| vit->start = 0; 825| 58.9k| vit->vec = vs.data.vecptr; 826| 58.9k| vit->end = igraph_vector_int_size(vit->vec); 827| 58.9k| if (!igraph_vector_int_isininterval(vit->vec, 0, igraph_vcount(graph) - 1)) { ------------------ | Branch (827:13): [True: 0, False: 58.9k] ------------------ 828| 0| IGRAPH_ERROR("Cannot create iterator, invalid vertex ID.", IGRAPH_EINVVID); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 829| 0| } 830| 58.9k| break; 831| 58.9k| case IGRAPH_VS_RANGE: ------------------ | Branch (831:5): [True: 0, False: 120k] ------------------ 832| 0| { 833| 0| igraph_integer_t no_of_nodes = igraph_vcount(graph); 834| 0| if (vs.data.range.start < 0 || ------------------ | Branch (834:17): [True: 0, False: 0] ------------------ 835| 0| vs.data.range.start > no_of_nodes || ------------------ | Branch (835:17): [True: 0, False: 0] ------------------ 836| 0| (no_of_nodes > 0 && vs.data.range.start == no_of_nodes)) { ------------------ | Branch (836:18): [True: 0, False: 0] | Branch (836:37): [True: 0, False: 0] ------------------ 837| 0| IGRAPH_ERROR("Cannot create range iterator, starting vertex ID out of range.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 838| 0| } 839| 0| if (vs.data.range.end < 0 || vs.data.range.end > no_of_nodes) { ------------------ | Branch (839:17): [True: 0, False: 0] | Branch (839:42): [True: 0, False: 0] ------------------ 840| 0| IGRAPH_ERROR("Cannot create range iterator, ending vertex ID out of range.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 841| 0| } 842| 0| } 843| 0| vit->type = IGRAPH_VIT_RANGE; 844| 0| vit->pos = vs.data.range.start; 845| 0| vit->start = vs.data.range.start; 846| 0| vit->end = vs.data.range.end; 847| 0| break; 848| 0| default: ------------------ | Branch (848:5): [True: 0, False: 120k] ------------------ 849| 0| IGRAPH_ERROR("Cannot create iterator, invalid selector.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 850| 0| break; 851| 120k| } 852| 120k| return IGRAPH_SUCCESS; 853| 120k|} igraph_vit_destroy: 868| 120k|void igraph_vit_destroy(const igraph_vit_t *vit) { 869| 120k| switch (vit->type) { 870| 61.2k| case IGRAPH_VIT_RANGE: ------------------ | Branch (870:5): [True: 61.2k, False: 58.9k] ------------------ 871| 120k| case IGRAPH_VIT_VECTORPTR: ------------------ | Branch (871:5): [True: 58.9k, False: 61.2k] ------------------ 872| 120k| break; 873| 0| case IGRAPH_VIT_VECTOR: ------------------ | Branch (873:5): [True: 0, False: 120k] ------------------ 874| 0| igraph_vector_int_destroy((igraph_vector_int_t*) vit->vec); 875| 0| igraph_free((igraph_vector_int_t*) vit->vec); 876| 0| break; 877| 0| default: ------------------ | Branch (877:5): [True: 0, False: 120k] ------------------ 878| | /* IGRAPH_ERROR("Cannot destroy iterator, unknown type", IGRAPH_EINVAL); */ 879| 0| break; 880| 120k| } 881| 120k|} igraph_vit_as_vector: 883| 8.01k|igraph_error_t igraph_vit_as_vector(const igraph_vit_t *vit, igraph_vector_int_t *v) { 884| 8.01k| igraph_integer_t i; 885| | 886| 8.01k| IGRAPH_CHECK(igraph_vector_int_resize(v, IGRAPH_VIT_SIZE(*vit))); ------------------ | | 752| 8.01k| do { \ | | 753| 8.01k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 8.01k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 8.01k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 8.01k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 8.01k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 887| | 888| 8.01k| switch (vit->type) { 889| 0| case IGRAPH_VIT_RANGE: ------------------ | Branch (889:5): [True: 0, False: 8.01k] ------------------ 890| 0| for (i = 0; i < IGRAPH_VIT_SIZE(*vit); i++) { ------------------ | | 194| 0|#define IGRAPH_VIT_SIZE(vit) ((vit).end - (vit).start) ------------------ | Branch (890:21): [True: 0, False: 0] ------------------ 891| 0| VECTOR(*v)[i] = vit->start + i; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 892| 0| } 893| 0| break; 894| 0| case IGRAPH_VIT_VECTOR: ------------------ | Branch (894:5): [True: 0, False: 8.01k] ------------------ 895| 8.01k| case IGRAPH_VIT_VECTORPTR: ------------------ | Branch (895:5): [True: 8.01k, False: 0] ------------------ 896| 34.4k| for (i = 0; i < IGRAPH_VIT_SIZE(*vit); i++) { ------------------ | | 194| 34.4k|#define IGRAPH_VIT_SIZE(vit) ((vit).end - (vit).start) ------------------ | Branch (896:21): [True: 26.4k, False: 8.01k] ------------------ 897| 26.4k| VECTOR(*v)[i] = VECTOR(*vit->vec)[i]; ------------------ | | 69| 26.4k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*v)[i] = VECTOR(*vit->vec)[i]; ------------------ | | 69| 26.4k|#define VECTOR(v) ((v).stor_begin) ------------------ 898| 26.4k| } 899| 8.01k| break; 900| 0| default: ------------------ | Branch (900:5): [True: 0, False: 8.01k] ------------------ 901| 0| IGRAPH_ERROR("Cannot convert to vector, unknown iterator type", ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 902| 0| IGRAPH_EINVAL); 903| 0| break; 904| 8.01k| } 905| | 906| 8.01k| return IGRAPH_SUCCESS; 907| 8.01k|} igraph_es_all: 933| 51.5k| igraph_edgeorder_type_t order) { 934| 51.5k| switch (order) { 935| 45.5k| case IGRAPH_EDGEORDER_ID: ------------------ | Branch (935:5): [True: 45.5k, False: 6.07k] ------------------ 936| 45.5k| es->type = IGRAPH_ES_ALL; 937| 45.5k| break; 938| 6.07k| case IGRAPH_EDGEORDER_FROM: ------------------ | Branch (938:5): [True: 6.07k, False: 45.5k] ------------------ 939| 6.07k| es->type = IGRAPH_ES_ALLFROM; 940| 6.07k| break; 941| 0| case IGRAPH_EDGEORDER_TO: ------------------ | Branch (941:5): [True: 0, False: 51.5k] ------------------ 942| 0| es->type = IGRAPH_ES_ALLTO; 943| 0| break; 944| 0| default: ------------------ | Branch (944:5): [True: 0, False: 51.5k] ------------------ 945| 0| IGRAPH_ERROR("Invalid edge order, cannot create selector.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 946| 0| break; 947| 51.5k| } 948| 51.5k| return IGRAPH_SUCCESS; 949| 51.5k|} igraph_ess_all: 965| 45.5k|igraph_es_t igraph_ess_all(igraph_edgeorder_type_t order) { 966| 45.5k| igraph_es_t es; 967| 45.5k| igraph_es_all(&es, order); /* cannot fail */ 968| 45.5k| return es; 969| 45.5k|} igraph_es_destroy: 1453| 6.07k|void igraph_es_destroy(igraph_es_t *es) { 1454| 6.07k| switch (es->type) { 1455| 0| case IGRAPH_ES_ALL: ------------------ | Branch (1455:5): [True: 0, False: 6.07k] ------------------ 1456| 6.07k| case IGRAPH_ES_ALLFROM: ------------------ | Branch (1456:5): [True: 6.07k, False: 0] ------------------ 1457| 6.07k| case IGRAPH_ES_ALLTO: ------------------ | Branch (1457:5): [True: 0, False: 6.07k] ------------------ 1458| 6.07k| case IGRAPH_ES_INCIDENT: ------------------ | Branch (1458:5): [True: 0, False: 6.07k] ------------------ 1459| 6.07k| case IGRAPH_ES_NONE: ------------------ | Branch (1459:5): [True: 0, False: 6.07k] ------------------ 1460| 6.07k| case IGRAPH_ES_1: ------------------ | Branch (1460:5): [True: 0, False: 6.07k] ------------------ 1461| 6.07k| case IGRAPH_ES_VECTORPTR: ------------------ | Branch (1461:5): [True: 0, False: 6.07k] ------------------ 1462| 6.07k| case IGRAPH_ES_RANGE: ------------------ | Branch (1462:5): [True: 0, False: 6.07k] ------------------ 1463| 6.07k| case IGRAPH_ES_ALL_BETWEEN: ------------------ | Branch (1463:5): [True: 0, False: 6.07k] ------------------ 1464| 6.07k| break; 1465| 0| case IGRAPH_ES_VECTOR: ------------------ | Branch (1465:5): [True: 0, False: 6.07k] ------------------ 1466| 0| igraph_vector_int_destroy((igraph_vector_int_t*)es->data.vecptr); 1467| 0| IGRAPH_FREE(es->data.vecptr); ------------------ | | 35| 0|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 1468| 0| break; 1469| 0| case IGRAPH_ES_PAIRS: ------------------ | Branch (1469:5): [True: 0, False: 6.07k] ------------------ 1470| 0| case IGRAPH_ES_PATH: ------------------ | Branch (1470:5): [True: 0, False: 6.07k] ------------------ 1471| 0| igraph_vector_int_destroy((igraph_vector_int_t*)es->data.path.ptr); 1472| 0| IGRAPH_FREE(es->data.path.ptr); ------------------ | | 35| 0|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 1473| 0| break; 1474| 0| default: ------------------ | Branch (1474:5): [True: 0, False: 6.07k] ------------------ 1475| 0| break; 1476| 6.07k| } 1477| 6.07k|} igraph_eit_create: 1958| 51.5k|igraph_error_t igraph_eit_create(const igraph_t *graph, igraph_es_t es, igraph_eit_t *eit) { 1959| 51.5k| switch (es.type) { 1960| 45.5k| case IGRAPH_ES_ALL: ------------------ | Branch (1960:5): [True: 45.5k, False: 6.07k] ------------------ 1961| 45.5k| eit->type = IGRAPH_EIT_RANGE; 1962| 45.5k| eit->pos = 0; 1963| 45.5k| eit->start = 0; 1964| 45.5k| eit->end = igraph_ecount(graph); 1965| 45.5k| break; 1966| 6.07k| case IGRAPH_ES_ALLFROM: ------------------ | Branch (1966:5): [True: 6.07k, False: 45.5k] ------------------ 1967| 6.07k| IGRAPH_CHECK(igraph_i_eit_create_allfromto(graph, eit, IGRAPH_OUT)); ------------------ | | 752| 6.07k| do { \ | | 753| 6.07k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 6.07k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 6.07k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 6.07k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 6.07k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1968| 6.07k| break; 1969| 6.07k| case IGRAPH_ES_ALLTO: ------------------ | Branch (1969:5): [True: 0, False: 51.5k] ------------------ 1970| 0| IGRAPH_CHECK(igraph_i_eit_create_allfromto(graph, eit, IGRAPH_IN)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1971| 0| break; 1972| 0| case IGRAPH_ES_INCIDENT: ------------------ | Branch (1972:5): [True: 0, False: 51.5k] ------------------ 1973| 0| IGRAPH_CHECK(igraph_i_eit_create_incident(graph, es, eit)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1974| 0| break; 1975| 0| case IGRAPH_ES_NONE: ------------------ | Branch (1975:5): [True: 0, False: 51.5k] ------------------ 1976| 0| eit->type = IGRAPH_EIT_RANGE; 1977| 0| eit->pos = 0; 1978| 0| eit->start = 0; 1979| 0| eit->end = 0; 1980| 0| break; 1981| 0| case IGRAPH_ES_1: ------------------ | Branch (1981:5): [True: 0, False: 51.5k] ------------------ 1982| 0| eit->type = IGRAPH_EIT_RANGE; 1983| 0| eit->pos = es.data.eid; 1984| 0| eit->start = es.data.eid; 1985| 0| eit->end = es.data.eid + 1; 1986| 0| if (eit->pos >= igraph_ecount(graph)) { ------------------ | Branch (1986:13): [True: 0, False: 0] ------------------ 1987| 0| IGRAPH_ERROR("Cannot create iterator, invalid edge ID.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1988| 0| } 1989| 0| break; 1990| 0| case IGRAPH_ES_VECTOR: ------------------ | Branch (1990:5): [True: 0, False: 51.5k] ------------------ 1991| 0| case IGRAPH_ES_VECTORPTR: ------------------ | Branch (1991:5): [True: 0, False: 51.5k] ------------------ 1992| 0| eit->type = IGRAPH_EIT_VECTORPTR; 1993| 0| eit->pos = 0; 1994| 0| eit->start = 0; 1995| 0| eit->vec = es.data.vecptr; 1996| 0| eit->end = igraph_vector_int_size(eit->vec); 1997| 0| if (!igraph_vector_int_isininterval(eit->vec, 0, igraph_ecount(graph) - 1)) { ------------------ | Branch (1997:13): [True: 0, False: 0] ------------------ 1998| 0| IGRAPH_ERROR("Cannot create iterator, invalid edge ID.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1999| 0| } 2000| 0| break; 2001| 0| case IGRAPH_ES_RANGE: ------------------ | Branch (2001:5): [True: 0, False: 51.5k] ------------------ 2002| 0| { 2003| 0| igraph_integer_t no_of_edges = igraph_ecount(graph); 2004| 0| if (es.data.range.start < 0 || ------------------ | Branch (2004:17): [True: 0, False: 0] ------------------ 2005| 0| es.data.range.start > no_of_edges || ------------------ | Branch (2005:17): [True: 0, False: 0] ------------------ 2006| 0| (no_of_edges > 0 && es.data.range.start == no_of_edges)) { ------------------ | Branch (2006:18): [True: 0, False: 0] | Branch (2006:37): [True: 0, False: 0] ------------------ 2007| 0| IGRAPH_ERROR("Cannot create range iterator, starting edge ID out of range.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 2008| 0| } 2009| 0| if (es.data.range.end < 0 || es.data.range.end > no_of_edges) { ------------------ | Branch (2009:17): [True: 0, False: 0] | Branch (2009:42): [True: 0, False: 0] ------------------ 2010| 0| IGRAPH_ERROR("Cannot create range iterator, ending edge ID out of range.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 2011| 0| } 2012| 0| } 2013| 0| eit->type = IGRAPH_EIT_RANGE; 2014| 0| eit->pos = es.data.range.start; 2015| 0| eit->start = es.data.range.start; 2016| 0| eit->end = es.data.range.end; 2017| 0| break; 2018| 0| case IGRAPH_ES_PAIRS: ------------------ | Branch (2018:5): [True: 0, False: 51.5k] ------------------ 2019| 0| IGRAPH_CHECK(igraph_i_eit_pairs(graph, es, eit)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2020| 0| break; 2021| 0| case IGRAPH_ES_PATH: ------------------ | Branch (2021:5): [True: 0, False: 51.5k] ------------------ 2022| 0| IGRAPH_CHECK(igraph_i_eit_path(graph, es, eit)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2023| 0| break; 2024| 0| case IGRAPH_ES_ALL_BETWEEN: ------------------ | Branch (2024:5): [True: 0, False: 51.5k] ------------------ 2025| 0| IGRAPH_CHECK(igraph_i_eit_all_between(graph, es, eit)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 2026| 0| break; 2027| 0| default: ------------------ | Branch (2027:5): [True: 0, False: 51.5k] ------------------ 2028| 0| IGRAPH_ERROR("Cannot create iterator, invalid selector.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 2029| 0| break; 2030| 51.5k| } 2031| 51.5k| return IGRAPH_SUCCESS; 2032| 51.5k|} igraph_eit_destroy: 2044| 51.5k|void igraph_eit_destroy(const igraph_eit_t *eit) { 2045| 51.5k| switch (eit->type) { 2046| 45.5k| case IGRAPH_EIT_RANGE: ------------------ | Branch (2046:5): [True: 45.5k, False: 6.07k] ------------------ 2047| 45.5k| case IGRAPH_EIT_VECTORPTR: ------------------ | Branch (2047:5): [True: 0, False: 51.5k] ------------------ 2048| 45.5k| break; 2049| 6.07k| case IGRAPH_EIT_VECTOR: ------------------ | Branch (2049:5): [True: 6.07k, False: 45.5k] ------------------ 2050| 6.07k| igraph_vector_int_destroy((igraph_vector_int_t*)eit->vec); 2051| 6.07k| igraph_free((igraph_vector_int_t*)eit->vec); 2052| 6.07k| break; 2053| 0| default: ------------------ | Branch (2053:5): [True: 0, False: 51.5k] ------------------ 2054| | /* IGRAPH_ERROR("Cannot destroy iterator, unknown type", IGRAPH_EINVAL); */ 2055| 0| break; 2056| 51.5k| } 2057| 51.5k|} iterators.c:igraph_i_eit_create_allfromto: 1733| 6.07k| igraph_neimode_t mode) { 1734| 6.07k| igraph_vector_int_t *vec; 1735| 6.07k| igraph_integer_t no_of_nodes = igraph_vcount(graph); 1736| 6.07k| igraph_integer_t no_of_edges = igraph_ecount(graph); 1737| 6.07k| igraph_integer_t i, j, length; 1738| | 1739| 6.07k| vec = IGRAPH_CALLOC(1, igraph_vector_int_t); ------------------ | | 32| 6.07k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 1740| 6.07k| IGRAPH_CHECK_OOM(vec, "Cannot create edge iterator."); ------------------ | | 807| 6.07k| do { \ | | 808| 6.07k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 6.07k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 6.07k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 6.07k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 1741| 6.07k| IGRAPH_FINALLY(igraph_free, vec); ------------------ | | 695| 6.07k| do { \ | | 696| 6.07k| /* the following branch makes the compiler check the compatibility of \ | | 697| 6.07k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 6.07k| * incorrect destructor function with the pointer */ \ | | 699| 6.07k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 6.07k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 6.07k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 1742| 6.07k| IGRAPH_VECTOR_INT_INIT_FINALLY(vec, 0); ------------------ | | 124| 6.07k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 6.07k| do { \ | | | | 753| 6.07k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 6.07k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 6.07k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 6.07k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 6.07k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 6.07k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 6.07k| do { \ | | | | 696| 6.07k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 6.07k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 6.07k| * incorrect destructor function with the pointer */ \ | | | | 699| 6.07k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 6.07k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 6.07k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 1743| 6.07k| IGRAPH_CHECK(igraph_vector_int_reserve(vec, no_of_edges)); ------------------ | | 752| 6.07k| do { \ | | 753| 6.07k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 6.07k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 6.07k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 6.07k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 6.07k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1744| | 1745| 6.07k| if (igraph_is_directed(graph)) { ------------------ | Branch (1745:9): [True: 5.36k, False: 709] ------------------ 1746| 5.36k| igraph_vector_int_t adj; 1747| 5.36k| IGRAPH_VECTOR_INT_INIT_FINALLY(&adj, 0); ------------------ | | 124| 5.36k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 5.36k| do { \ | | | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 5.36k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 5.36k| do { \ | | | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | | | 699| 5.36k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 1748| 27.0k| for (i = 0; i < no_of_nodes; i++) { ------------------ | Branch (1748:21): [True: 21.7k, False: 5.36k] ------------------ 1749| 21.7k| IGRAPH_CHECK(igraph_incident(graph, &adj, i, mode)); ------------------ | | 752| 21.7k| do { \ | | 753| 21.7k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 21.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 21.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 21.7k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 21.7k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1750| 21.7k| igraph_vector_int_append(vec, &adj); /* reserved */ 1751| 21.7k| } 1752| 5.36k| igraph_vector_int_destroy(&adj); 1753| 5.36k| IGRAPH_FINALLY_CLEAN(1); 1754| | 1755| 5.36k| } else { 1756| | 1757| 709| igraph_vector_int_t adj; 1758| 709| igraph_bool_t *added; 1759| 709| IGRAPH_VECTOR_INT_INIT_FINALLY(&adj, 0); ------------------ | | 124| 709| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 709| do { \ | | | | 753| 709| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 709| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 709] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 709| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 709| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 709| do { \ | | | | 696| 709| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 709| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 709| * incorrect destructor function with the pointer */ \ | | | | 699| 709| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 709| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 709| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 1760| 709| added = IGRAPH_CALLOC(no_of_edges, igraph_bool_t); ------------------ | | 32| 709|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [True: 709, False: 0] | | ------------------ ------------------ 1761| 709| IGRAPH_CHECK_OOM(added, "Cannot create edge iterator."); ------------------ | | 807| 709| do { \ | | 808| 709| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 709| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 709] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 709| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 1762| 709| IGRAPH_FINALLY(igraph_free, added); ------------------ | | 695| 709| do { \ | | 696| 709| /* the following branch makes the compiler check the compatibility of \ | | 697| 709| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 709| * incorrect destructor function with the pointer */ \ | | 699| 709| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 709| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 709| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 1763| 7.90k| for (i = 0; i < no_of_nodes; i++) { ------------------ | Branch (1763:21): [True: 7.19k, False: 709] ------------------ 1764| 7.19k| IGRAPH_CHECK(igraph_incident(graph, &adj, i, IGRAPH_ALL)); ------------------ | | 752| 7.19k| do { \ | | 753| 7.19k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 7.19k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 7.19k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 7.19k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 7.19k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1765| 7.19k| length = igraph_vector_int_size(&adj); 1766| 36.5k| for (j = 0; j < length; j++) { ------------------ | Branch (1766:25): [True: 29.3k, False: 7.19k] ------------------ 1767| 29.3k| if (!added[ VECTOR(adj)[j] ]) { ------------------ | | 69| 29.3k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1767:21): [True: 14.6k, False: 14.6k] ------------------ 1768| 14.6k| igraph_vector_int_push_back(vec, VECTOR(adj)[j]); /* reserved */ ------------------ | | 69| 14.6k|#define VECTOR(v) ((v).stor_begin) ------------------ 1769| 14.6k| added[ VECTOR(adj)[j] ] += 1; ------------------ | | 69| 14.6k|#define VECTOR(v) ((v).stor_begin) ------------------ 1770| 14.6k| } 1771| 29.3k| } 1772| 7.19k| } 1773| 709| igraph_vector_int_destroy(&adj); 1774| 709| IGRAPH_FREE(added); ------------------ | | 35| 709|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 1775| 709| IGRAPH_FINALLY_CLEAN(2); 1776| 709| } 1777| | 1778| 6.07k| eit->type = IGRAPH_EIT_VECTOR; 1779| 6.07k| eit->pos = 0; 1780| 6.07k| eit->start = 0; 1781| 6.07k| eit->vec = vec; 1782| 6.07k| eit->end = igraph_vector_int_size(eit->vec); 1783| | 1784| 6.07k| IGRAPH_FINALLY_CLEAN(2); 1785| 6.07k| return IGRAPH_SUCCESS; 1786| 6.07k|} igraph_empty: 65| 42.7k|igraph_error_t igraph_empty(igraph_t *graph, igraph_integer_t n, igraph_bool_t directed) { 66| 42.7k| return igraph_empty_attrs(graph, n, directed, 0); 67| 42.7k|} igraph_edge: 120| 3.13M|) { 121| | 122| 3.13M| if (eid < 0 || eid >= igraph_ecount(graph)) { ------------------ | Branch (122:9): [True: 0, False: 3.13M] | Branch (122:20): [True: 0, False: 3.13M] ------------------ 123| 0| IGRAPH_ERROR("Invalid edge ID when retrieving edge endpoints.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 124| 0| } 125| | 126| 3.13M| if (igraph_is_directed(graph)) { ------------------ | Branch (126:9): [True: 3.11M, False: 17.9k] ------------------ 127| 3.11M| *from = IGRAPH_FROM(graph, eid); ------------------ | | 103| 3.11M|#define IGRAPH_FROM(graph,eid) ((igraph_integer_t)(VECTOR((graph)->from)[(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 3.11M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 128| 3.11M| *to = IGRAPH_TO(graph, eid); ------------------ | | 116| 3.11M|#define IGRAPH_TO(graph,eid) ((igraph_integer_t)(VECTOR((graph)->to) [(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 3.11M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 129| 3.11M| } else { 130| 17.9k| *from = IGRAPH_TO(graph, eid); ------------------ | | 116| 17.9k|#define IGRAPH_TO(graph,eid) ((igraph_integer_t)(VECTOR((graph)->to) [(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 17.9k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 131| 17.9k| *to = IGRAPH_FROM(graph, eid); ------------------ | | 103| 17.9k|#define IGRAPH_FROM(graph,eid) ((igraph_integer_t)(VECTOR((graph)->from)[(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 17.9k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 132| 17.9k| } 133| | 134| 3.13M| return IGRAPH_SUCCESS; 135| 3.13M|} igraph_empty_attrs: 98| 42.7k|igraph_error_t igraph_empty_attrs(igraph_t *graph, igraph_integer_t n, igraph_bool_t directed, void *attr) { 99| | 100| 42.7k| if (n < 0) { ------------------ | Branch (100:9): [True: 0, False: 42.7k] ------------------ 101| 0| IGRAPH_ERROR("Number of vertices must not be negative.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 102| 0| } 103| | 104| 42.7k| graph->n = 0; 105| 42.7k| graph->directed = directed; 106| 42.7k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->from, 0); ------------------ | | 124| 42.7k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 42.7k| do { \ | | | | 753| 42.7k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 42.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 42.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 42.7k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 42.7k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 42.7k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 42.7k| do { \ | | | | 696| 42.7k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 42.7k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 42.7k| * incorrect destructor function with the pointer */ \ | | | | 699| 42.7k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 42.7k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 42.7k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 107| 42.7k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->to, 0); ------------------ | | 124| 42.7k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 42.7k| do { \ | | | | 753| 42.7k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 42.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 42.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 42.7k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 42.7k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 42.7k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 42.7k| do { \ | | | | 696| 42.7k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 42.7k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 42.7k| * incorrect destructor function with the pointer */ \ | | | | 699| 42.7k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 42.7k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 42.7k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 108| 42.7k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->oi, 0); ------------------ | | 124| 42.7k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 42.7k| do { \ | | | | 753| 42.7k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 42.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 42.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 42.7k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 42.7k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 42.7k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 42.7k| do { \ | | | | 696| 42.7k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 42.7k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 42.7k| * incorrect destructor function with the pointer */ \ | | | | 699| 42.7k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 42.7k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 42.7k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 109| 42.7k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->ii, 0); ------------------ | | 124| 42.7k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 42.7k| do { \ | | | | 753| 42.7k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 42.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 42.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 42.7k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 42.7k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 42.7k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 42.7k| do { \ | | | | 696| 42.7k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 42.7k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 42.7k| * incorrect destructor function with the pointer */ \ | | | | 699| 42.7k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 42.7k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 42.7k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 110| 42.7k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->os, 1); ------------------ | | 124| 42.7k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 42.7k| do { \ | | | | 753| 42.7k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 42.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 42.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 42.7k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 42.7k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 42.7k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 42.7k| do { \ | | | | 696| 42.7k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 42.7k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 42.7k| * incorrect destructor function with the pointer */ \ | | | | 699| 42.7k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 42.7k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 42.7k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 111| 42.7k| IGRAPH_VECTOR_INT_INIT_FINALLY(&graph->is, 1); ------------------ | | 124| 42.7k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 42.7k| do { \ | | | | 753| 42.7k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 42.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 42.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 42.7k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 42.7k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 42.7k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 42.7k| do { \ | | | | 696| 42.7k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 42.7k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 42.7k| * incorrect destructor function with the pointer */ \ | | | | 699| 42.7k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 42.7k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 42.7k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 112| | 113| | /* init cache */ 114| 42.7k| graph->cache = IGRAPH_CALLOC(1, igraph_i_property_cache_t); ------------------ | | 32| 42.7k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 115| 42.7k| IGRAPH_CHECK_OOM(graph->cache, "Cannot create graph."); ------------------ | | 807| 42.7k| do { \ | | 808| 42.7k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 42.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 42.7k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 42.7k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 116| 42.7k| IGRAPH_FINALLY(igraph_free, graph->cache); ------------------ | | 695| 42.7k| do { \ | | 696| 42.7k| /* the following branch makes the compiler check the compatibility of \ | | 697| 42.7k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 42.7k| * incorrect destructor function with the pointer */ \ | | 699| 42.7k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 42.7k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 42.7k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 117| 42.7k| IGRAPH_CHECK(igraph_i_property_cache_init(graph->cache)); ------------------ | | 752| 42.7k| do { \ | | 753| 42.7k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 42.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 42.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 42.7k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 42.7k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 118| 42.7k| IGRAPH_FINALLY(igraph_i_property_cache_destroy, graph->cache); ------------------ | | 695| 42.7k| do { \ | | 696| 42.7k| /* the following branch makes the compiler check the compatibility of \ | | 697| 42.7k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 42.7k| * incorrect destructor function with the pointer */ \ | | 699| 42.7k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 42.7k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 42.7k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 119| | 120| 42.7k| VECTOR(graph->os)[0] = 0; ------------------ | | 69| 42.7k|#define VECTOR(v) ((v).stor_begin) ------------------ 121| 42.7k| VECTOR(graph->is)[0] = 0; ------------------ | | 69| 42.7k|#define VECTOR(v) ((v).stor_begin) ------------------ 122| | 123| | /* init attributes */ 124| 42.7k| graph->attr = 0; 125| 42.7k| IGRAPH_CHECK(igraph_i_attribute_init(graph, attr)); ------------------ | | 752| 42.7k| do { \ | | 753| 42.7k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 42.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 42.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 42.7k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 42.7k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 126| | 127| | /* add the vertices */ 128| 42.7k| IGRAPH_CHECK(igraph_add_vertices(graph, n, 0)); ------------------ | | 752| 42.7k| do { \ | | 753| 42.7k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 42.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 42.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 42.7k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 42.7k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 129| | 130| 42.7k| IGRAPH_FINALLY_CLEAN(8); 131| 42.7k| return IGRAPH_SUCCESS; 132| 42.7k|} igraph_destroy: 150| 94.4k|void igraph_destroy(igraph_t *graph) { 151| | 152| 94.4k| IGRAPH_I_ATTRIBUTE_DESTROY(graph); ------------------ | | 30| 94.4k| do {if ((graph)->attr) igraph_i_attribute_destroy(graph);} while(0) | | ------------------ | | | Branch (30:13): [True: 0, False: 94.4k] | | | Branch (30:70): [Folded - Ignored] | | ------------------ ------------------ 153| | 154| 94.4k| igraph_i_property_cache_destroy(graph->cache); 155| 94.4k| IGRAPH_FREE(graph->cache); ------------------ | | 35| 94.4k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 156| | 157| 94.4k| igraph_vector_int_destroy(&graph->from); 158| 94.4k| igraph_vector_int_destroy(&graph->to); 159| 94.4k| igraph_vector_int_destroy(&graph->oi); 160| 94.4k| igraph_vector_int_destroy(&graph->ii); 161| 94.4k| igraph_vector_int_destroy(&graph->os); 162| 94.4k| igraph_vector_int_destroy(&graph->is); 163| 94.4k|} igraph_copy: 191| 26.6k|igraph_error_t igraph_copy(igraph_t *to, const igraph_t *from) { 192| 26.6k| to->n = from->n; 193| 26.6k| to->directed = from->directed; 194| 26.6k| IGRAPH_CHECK(igraph_vector_int_init_copy(&to->from, &from->from)); ------------------ | | 752| 26.6k| do { \ | | 753| 26.6k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 26.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 26.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 26.6k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 26.6k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 195| 26.6k| IGRAPH_FINALLY(igraph_vector_int_destroy, &to->from); ------------------ | | 695| 26.6k| do { \ | | 696| 26.6k| /* the following branch makes the compiler check the compatibility of \ | | 697| 26.6k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 26.6k| * incorrect destructor function with the pointer */ \ | | 699| 26.6k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 26.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 26.6k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 196| 26.6k| IGRAPH_CHECK(igraph_vector_int_init_copy(&to->to, &from->to)); ------------------ | | 752| 26.6k| do { \ | | 753| 26.6k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 26.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 26.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 26.6k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 26.6k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 197| 26.6k| IGRAPH_FINALLY(igraph_vector_int_destroy, &to->to); ------------------ | | 695| 26.6k| do { \ | | 696| 26.6k| /* the following branch makes the compiler check the compatibility of \ | | 697| 26.6k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 26.6k| * incorrect destructor function with the pointer */ \ | | 699| 26.6k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 26.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 26.6k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 198| 26.6k| IGRAPH_CHECK(igraph_vector_int_init_copy(&to->oi, &from->oi)); ------------------ | | 752| 26.6k| do { \ | | 753| 26.6k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 26.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 26.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 26.6k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 26.6k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 199| 26.6k| IGRAPH_FINALLY(igraph_vector_int_destroy, &to->oi); ------------------ | | 695| 26.6k| do { \ | | 696| 26.6k| /* the following branch makes the compiler check the compatibility of \ | | 697| 26.6k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 26.6k| * incorrect destructor function with the pointer */ \ | | 699| 26.6k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 26.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 26.6k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 200| 26.6k| IGRAPH_CHECK(igraph_vector_int_init_copy(&to->ii, &from->ii)); ------------------ | | 752| 26.6k| do { \ | | 753| 26.6k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 26.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 26.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 26.6k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 26.6k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 201| 26.6k| IGRAPH_FINALLY(igraph_vector_int_destroy, &to->ii); ------------------ | | 695| 26.6k| do { \ | | 696| 26.6k| /* the following branch makes the compiler check the compatibility of \ | | 697| 26.6k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 26.6k| * incorrect destructor function with the pointer */ \ | | 699| 26.6k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 26.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 26.6k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 202| 26.6k| IGRAPH_CHECK(igraph_vector_int_init_copy(&to->os, &from->os)); ------------------ | | 752| 26.6k| do { \ | | 753| 26.6k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 26.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 26.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 26.6k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 26.6k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 203| 26.6k| IGRAPH_FINALLY(igraph_vector_int_destroy, &to->os); ------------------ | | 695| 26.6k| do { \ | | 696| 26.6k| /* the following branch makes the compiler check the compatibility of \ | | 697| 26.6k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 26.6k| * incorrect destructor function with the pointer */ \ | | 699| 26.6k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 26.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 26.6k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 204| 26.6k| IGRAPH_CHECK(igraph_vector_int_init_copy(&to->is, &from->is)); ------------------ | | 752| 26.6k| do { \ | | 753| 26.6k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 26.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 26.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 26.6k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 26.6k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 205| 26.6k| IGRAPH_FINALLY(igraph_vector_int_destroy, &to->is); ------------------ | | 695| 26.6k| do { \ | | 696| 26.6k| /* the following branch makes the compiler check the compatibility of \ | | 697| 26.6k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 26.6k| * incorrect destructor function with the pointer */ \ | | 699| 26.6k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 26.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 26.6k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 206| | 207| 26.6k| to->cache = IGRAPH_CALLOC(1, igraph_i_property_cache_t); ------------------ | | 32| 26.6k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 208| 26.6k| IGRAPH_CHECK_OOM(to->cache, "Cannot copy graph."); ------------------ | | 807| 26.6k| do { \ | | 808| 26.6k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 26.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 26.6k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 26.6k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 209| 26.6k| IGRAPH_FINALLY(igraph_free, to->cache); ------------------ | | 695| 26.6k| do { \ | | 696| 26.6k| /* the following branch makes the compiler check the compatibility of \ | | 697| 26.6k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 26.6k| * incorrect destructor function with the pointer */ \ | | 699| 26.6k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 26.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 26.6k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 210| 26.6k| IGRAPH_CHECK(igraph_i_property_cache_copy(to->cache, from->cache)); ------------------ | | 752| 26.6k| do { \ | | 753| 26.6k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 26.6k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 26.6k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 26.6k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 26.6k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 211| 26.6k| IGRAPH_FINALLY(igraph_i_property_cache_destroy, to->cache); ------------------ | | 695| 26.6k| do { \ | | 696| 26.6k| /* the following branch makes the compiler check the compatibility of \ | | 697| 26.6k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 26.6k| * incorrect destructor function with the pointer */ \ | | 699| 26.6k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 26.6k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 26.6k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 212| | 213| 26.6k| IGRAPH_I_ATTRIBUTE_COPY(to, from, true, true, true); /* does IGRAPH_CHECK */ ------------------ | | 31| 26.6k|#define IGRAPH_I_ATTRIBUTE_COPY(to,from,ga,va,ea) do { \ | | 32| 26.6k| igraph_error_t igraph_i_ret2=IGRAPH_SUCCESS; \ | | 33| 26.6k| if ((from)->attr) { \ | | ------------------ | | | Branch (33:13): [True: 0, False: 26.6k] | | ------------------ | | 34| 0| IGRAPH_CHECK(igraph_i_ret2=igraph_i_attribute_copy((to),(from),(ga),(va),(ea))); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 35| 26.6k| } else { \ | | 36| 26.6k| (to)->attr = NULL; \ | | 37| 26.6k| } \ | | 38| 26.6k| if (igraph_i_ret2 != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (38:13): [True: 0, False: 26.6k] | | ------------------ | | 39| 0| IGRAPH_ERROR("", igraph_i_ret2); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 40| 0| } \ | | 41| 26.6k| } while(0) | | ------------------ | | | Branch (41:13): [Folded - Ignored] | | ------------------ ------------------ 214| | 215| 26.6k| IGRAPH_FINALLY_CLEAN(8); 216| 26.6k| return IGRAPH_SUCCESS; 217| 26.6k|} igraph_add_edges: 249| 68.9k| void *attr) { 250| 68.9k| igraph_integer_t no_of_edges = igraph_vector_int_size(&graph->from); 251| 68.9k| igraph_integer_t edges_to_add = igraph_vector_int_size(edges) / 2; 252| 68.9k| igraph_integer_t new_no_of_edges; 253| 68.9k| igraph_integer_t i = 0; 254| 68.9k| igraph_vector_int_t newoi, newii; 255| 68.9k| igraph_bool_t directed = igraph_is_directed(graph); 256| | 257| 68.9k| if (igraph_vector_int_size(edges) % 2 != 0) { ------------------ | Branch (257:9): [True: 0, False: 68.9k] ------------------ 258| 0| IGRAPH_ERROR("Invalid (odd) length of edges vector.", IGRAPH_EINVEVECTOR); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 259| 0| } 260| 68.9k| if (!igraph_vector_int_isininterval(edges, 0, igraph_vcount(graph) - 1)) { ------------------ | Branch (260:9): [True: 0, False: 68.9k] ------------------ 261| 0| IGRAPH_ERROR("Out-of-range vertex IDs when adding edges.", IGRAPH_EINVVID); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 262| 0| } 263| | 264| | /* from & to */ 265| 68.9k| IGRAPH_SAFE_ADD(no_of_edges, edges_to_add, &new_no_of_edges); ------------------ | | 47| 68.9k| do { \ | | 48| 68.9k| igraph_integer_t _safe_a = (a), _safe_b = (b); \ | | 49| 68.9k| igraph_integer_t _safe_sum; \ | | 50| 68.9k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 68.9k] | | ------------------ | | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \ | | ------------------ | | | | 550| 0| do { \ | | | | 551| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | | | 552| 0| igraph_errno, __VA_ARGS__) ; \ | | | | 553| 0| return igraph_errno; \ | | | | 554| 0| } while (0) | | | | ------------------ | | | | | Branch (554:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 52| 0| } \ | | 53| 68.9k| *(res) = _safe_sum; \ | | 54| 68.9k| } while (0) | | ------------------ | | | Branch (54:14): [Folded - Ignored] | | ------------------ ------------------ 266| 68.9k| if (new_no_of_edges > IGRAPH_ECOUNT_MAX) { ------------------ | | 122| 68.9k|#define IGRAPH_ECOUNT_MAX (IGRAPH_INTEGER_MAX/2) | | ------------------ | | | | 78| 68.9k|# define IGRAPH_INTEGER_MAX INT64_MAX | | ------------------ ------------------ | Branch (266:9): [True: 0, False: 68.9k] ------------------ 267| 0| IGRAPH_ERRORF("Maximum edge count (%" IGRAPH_PRId ") exceeded.", IGRAPH_ERANGE, ------------------ | | 550| 0| do { \ | | 551| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 552| 0| igraph_errno, __VA_ARGS__) ; \ | | 553| 0| return igraph_errno; \ | | 554| 0| } while (0) | | ------------------ | | | Branch (554:14): [Folded - Ignored] | | ------------------ ------------------ 268| 0| IGRAPH_ECOUNT_MAX); 269| 0| } 270| 68.9k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->from, no_of_edges + edges_to_add)); ------------------ | | 752| 68.9k| do { \ | | 753| 68.9k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 68.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 68.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 68.9k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 68.9k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 271| 68.9k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->to, no_of_edges + edges_to_add)); ------------------ | | 752| 68.9k| do { \ | | 753| 68.9k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 68.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 68.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 68.9k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 68.9k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 272| | 273| 1.35M| while (i < edges_to_add * 2) { ------------------ | Branch (273:12): [True: 1.28M, False: 68.9k] ------------------ 274| 1.28M| if (directed || VECTOR(*edges)[i] > VECTOR(*edges)[i + 1]) { ------------------ | | 69| 42.9k|#define VECTOR(v) ((v).stor_begin) ------------------ if (directed || VECTOR(*edges)[i] > VECTOR(*edges)[i + 1]) { ------------------ | | 69| 42.9k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (274:13): [True: 1.24M, False: 42.9k] | Branch (274:25): [True: 21.3k, False: 21.5k] ------------------ 275| 1.26M| igraph_vector_int_push_back(&graph->from, VECTOR(*edges)[i++]); /* reserved */ ------------------ | | 69| 1.26M|#define VECTOR(v) ((v).stor_begin) ------------------ 276| 1.26M| igraph_vector_int_push_back(&graph->to, VECTOR(*edges)[i++]); /* reserved */ ------------------ | | 69| 1.26M|#define VECTOR(v) ((v).stor_begin) ------------------ 277| 1.26M| } else { 278| 21.5k| igraph_vector_int_push_back(&graph->to, VECTOR(*edges)[i++]); /* reserved */ ------------------ | | 69| 21.5k|#define VECTOR(v) ((v).stor_begin) ------------------ 279| 21.5k| igraph_vector_int_push_back(&graph->from, VECTOR(*edges)[i++]); /* reserved */ ------------------ | | 69| 21.5k|#define VECTOR(v) ((v).stor_begin) ------------------ 280| 21.5k| } 281| 1.28M| } 282| | 283| | /* If an error occurs while the edges are being added, we make the necessary fixup 284| | * to ensure that the graph is still in a consistent state when this function returns. 285| | * The graph may already be on the finally stack when calling this function. We use 286| | * a separate finally stack level to avoid its destructor from being called on error, 287| | * so that the fixup can succeed. 288| | */ 289| | 290| 68.9k|#define CHECK_ERR(expr) \ 291| 68.9k| do { \ 292| 68.9k| igraph_error_t err = (expr); \ 293| 68.9k| if (err != IGRAPH_SUCCESS) { \ 294| 68.9k| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ 295| 68.9k| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ 296| 68.9k| IGRAPH_FINALLY_EXIT(); \ 297| 68.9k| IGRAPH_ERROR("Cannot add edges.", err); \ 298| 68.9k| } \ 299| 68.9k| } while (0) 300| | 301| | /* oi & ii */ 302| 68.9k| IGRAPH_FINALLY_ENTER(); 303| 68.9k| { 304| 68.9k| CHECK_ERR(igraph_vector_int_init(&newoi, no_of_edges)); ------------------ | | 291| 68.9k| do { \ | | 292| 68.9k| igraph_error_t err = (expr); \ | | 293| 68.9k| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (293:13): [True: 0, False: 68.9k] | | ------------------ | | 294| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ | | 295| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ | | 296| 0| IGRAPH_FINALLY_EXIT(); \ | | 297| 0| IGRAPH_ERROR("Cannot add edges.", err); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 298| 0| } \ | | 299| 68.9k| } while (0) | | ------------------ | | | Branch (299:14): [Folded - Ignored] | | ------------------ ------------------ 305| 68.9k| IGRAPH_FINALLY(igraph_vector_int_destroy, &newoi); ------------------ | | 695| 68.9k| do { \ | | 696| 68.9k| /* the following branch makes the compiler check the compatibility of \ | | 697| 68.9k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 68.9k| * incorrect destructor function with the pointer */ \ | | 699| 68.9k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 68.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 68.9k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 306| 68.9k| CHECK_ERR(igraph_vector_int_init(&newii, no_of_edges)); ------------------ | | 291| 68.9k| do { \ | | 292| 68.9k| igraph_error_t err = (expr); \ | | 293| 68.9k| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (293:13): [True: 0, False: 68.9k] | | ------------------ | | 294| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ | | 295| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ | | 296| 0| IGRAPH_FINALLY_EXIT(); \ | | 297| 0| IGRAPH_ERROR("Cannot add edges.", err); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 298| 0| } \ | | 299| 68.9k| } while (0) | | ------------------ | | | Branch (299:14): [Folded - Ignored] | | ------------------ ------------------ 307| 68.9k| IGRAPH_FINALLY(igraph_vector_int_destroy, &newii); ------------------ | | 695| 68.9k| do { \ | | 696| 68.9k| /* the following branch makes the compiler check the compatibility of \ | | 697| 68.9k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 68.9k| * incorrect destructor function with the pointer */ \ | | 699| 68.9k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 68.9k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 68.9k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 308| 68.9k| CHECK_ERR(igraph_vector_int_pair_order(&graph->from, &graph->to, &newoi, graph->n)); ------------------ | | 291| 68.9k| do { \ | | 292| 68.9k| igraph_error_t err = (expr); \ | | 293| 68.9k| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (293:13): [True: 0, False: 68.9k] | | ------------------ | | 294| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ | | 295| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ | | 296| 0| IGRAPH_FINALLY_EXIT(); \ | | 297| 0| IGRAPH_ERROR("Cannot add edges.", err); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 298| 0| } \ | | 299| 68.9k| } while (0) | | ------------------ | | | Branch (299:14): [Folded - Ignored] | | ------------------ ------------------ 309| 68.9k| CHECK_ERR(igraph_vector_int_pair_order(&graph->to, &graph->from, &newii, graph->n)); ------------------ | | 291| 68.9k| do { \ | | 292| 68.9k| igraph_error_t err = (expr); \ | | 293| 68.9k| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (293:13): [True: 0, False: 68.9k] | | ------------------ | | 294| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ | | 295| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ | | 296| 0| IGRAPH_FINALLY_EXIT(); \ | | 297| 0| IGRAPH_ERROR("Cannot add edges.", err); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 298| 0| } \ | | 299| 68.9k| } while (0) | | ------------------ | | | Branch (299:14): [Folded - Ignored] | | ------------------ ------------------ 310| | 311| | /* Attributes */ 312| 68.9k| if (graph->attr) { ------------------ | Branch (312:13): [True: 0, False: 68.9k] ------------------ 313| | /* TODO: Does this keep the attribute table in a consistent state upon failure? */ 314| 0| CHECK_ERR(igraph_i_attribute_add_edges(graph, edges, attr)); ------------------ | | 291| 0| do { \ | | 292| 0| igraph_error_t err = (expr); \ | | 293| 0| if (err != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (293:13): [True: 0, False: 0] | | ------------------ | | 294| 0| igraph_vector_int_resize(&graph->from, no_of_edges); /* gets smaller, error safe */ \ | | 295| 0| igraph_vector_int_resize(&graph->to, no_of_edges); /* gets smaller, error safe */ \ | | 296| 0| IGRAPH_FINALLY_EXIT(); \ | | 297| 0| IGRAPH_ERROR("Cannot add edges.", err); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 298| 0| } \ | | 299| 0| } while (0) | | ------------------ | | | Branch (299:14): [Folded - Ignored] | | ------------------ ------------------ 315| 0| } 316| | 317| | /* os & is, its length does not change, error safe */ 318| 68.9k| igraph_i_create_start_vectors(&graph->os, &graph->from, &newoi, graph->n); 319| 68.9k| igraph_i_create_start_vectors(&graph->is, &graph->to, &newii, graph->n); 320| | 321| | /* everything went fine */ 322| 68.9k| igraph_vector_int_destroy(&graph->oi); 323| 68.9k| igraph_vector_int_destroy(&graph->ii); 324| 68.9k| IGRAPH_FINALLY_CLEAN(2); 325| | 326| 68.9k| graph->oi = newoi; 327| 68.9k| graph->ii = newii; 328| 68.9k| } 329| 0| IGRAPH_FINALLY_EXIT(); 330| | 331| 68.9k|#undef CHECK_ERR 332| | 333| | /* modification successful, clear the cached properties of the graph. 334| | * 335| | * Adding one or more edges cannot make a strongly or weakly connected 336| | * graph disconnected, so we keep those flags if they are cached as true. 337| | * 338| | * Adding one or more edges may turn a DAG into a non-DAG or a forest into 339| | * a non-forest, so we can keep those flags only if they are cached as 340| | * false. 341| | * 342| | * Also, adding one or more edges does not change HAS_LOOP, HAS_MULTI and 343| | * HAS_MUTUAL if they were already true. 344| | */ 345| 68.9k| igraph_i_property_cache_invalidate_conditionally( 346| 68.9k| graph, 347| 68.9k| /* keep_always = */ 0, 348| | /* keep_when_false = */ 349| 68.9k| (1 << IGRAPH_PROP_IS_DAG) | (1 << IGRAPH_PROP_IS_FOREST), 350| | /* keep_when_true = */ 351| 68.9k| (1 << IGRAPH_PROP_IS_WEAKLY_CONNECTED) | 352| 68.9k| (1 << IGRAPH_PROP_IS_STRONGLY_CONNECTED) | 353| 68.9k| (1 << IGRAPH_PROP_HAS_LOOP) | 354| 68.9k| (1 << IGRAPH_PROP_HAS_MULTI) | 355| 68.9k| (1 << IGRAPH_PROP_HAS_MUTUAL) 356| 68.9k| ); 357| | 358| 68.9k| return IGRAPH_SUCCESS; 359| 68.9k|} igraph_add_vertices: 381| 43.9k|igraph_error_t igraph_add_vertices(igraph_t *graph, igraph_integer_t nv, void *attr) { 382| 43.9k| igraph_integer_t ec = igraph_ecount(graph); 383| 43.9k| igraph_integer_t vc = igraph_vcount(graph); 384| 43.9k| igraph_integer_t new_vc; 385| 43.9k| igraph_integer_t i; 386| | 387| 43.9k| if (nv < 0) { ------------------ | Branch (387:9): [True: 0, False: 43.9k] ------------------ 388| 0| IGRAPH_ERROR("Cannot add negative number of vertices.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 389| 0| } 390| | 391| 43.9k| IGRAPH_SAFE_ADD(graph->n, nv, &new_vc); ------------------ | | 47| 43.9k| do { \ | | 48| 43.9k| igraph_integer_t _safe_a = (a), _safe_b = (b); \ | | 49| 43.9k| igraph_integer_t _safe_sum; \ | | 50| 43.9k| if (__builtin_add_overflow(_safe_a, _safe_b, &_safe_sum)) { \ | | ------------------ | | | Branch (50:13): [True: 0, False: 43.9k] | | ------------------ | | 51| 0| IGRAPH_ERRORF("Overflow when adding %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \ | | ------------------ | | | | 550| 0| do { \ | | | | 551| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | | | 552| 0| igraph_errno, __VA_ARGS__) ; \ | | | | 553| 0| return igraph_errno; \ | | | | 554| 0| } while (0) | | | | ------------------ | | | | | Branch (554:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 52| 0| } \ | | 53| 43.9k| *(res) = _safe_sum; \ | | 54| 43.9k| } while (0) | | ------------------ | | | Branch (54:14): [Folded - Ignored] | | ------------------ ------------------ 392| 43.9k| if (new_vc > IGRAPH_VCOUNT_MAX) { ------------------ | | 106| 43.9k|#define IGRAPH_VCOUNT_MAX (IGRAPH_INTEGER_MAX-1) | | ------------------ | | | | 78| 43.9k|# define IGRAPH_INTEGER_MAX INT64_MAX | | ------------------ ------------------ | Branch (392:9): [True: 0, False: 43.9k] ------------------ 393| 0| IGRAPH_ERRORF("Maximum vertex count (%" IGRAPH_PRId ") exceeded.", IGRAPH_ERANGE, ------------------ | | 550| 0| do { \ | | 551| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 552| 0| igraph_errno, __VA_ARGS__) ; \ | | 553| 0| return igraph_errno; \ | | 554| 0| } while (0) | | ------------------ | | | Branch (554:14): [Folded - Ignored] | | ------------------ ------------------ 394| 0| IGRAPH_VCOUNT_MAX); 395| 0| } 396| 43.9k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->os, new_vc + 1)); ------------------ | | 752| 43.9k| do { \ | | 753| 43.9k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 43.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 43.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 43.9k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 43.9k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 397| 43.9k| IGRAPH_CHECK(igraph_vector_int_reserve(&graph->is, new_vc + 1)); ------------------ | | 752| 43.9k| do { \ | | 753| 43.9k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 43.9k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 43.9k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 43.9k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 43.9k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 398| | 399| 43.9k| igraph_vector_int_resize(&graph->os, new_vc + 1); /* reserved */ 400| 43.9k| igraph_vector_int_resize(&graph->is, new_vc + 1); /* reserved */ 401| 656k| for (i = graph->n + 1; i < new_vc + 1; i++) { ------------------ | Branch (401:28): [True: 612k, False: 43.9k] ------------------ 402| 612k| VECTOR(graph->os)[i] = ec; ------------------ | | 69| 612k|#define VECTOR(v) ((v).stor_begin) ------------------ 403| 612k| VECTOR(graph->is)[i] = ec; ------------------ | | 69| 612k|#define VECTOR(v) ((v).stor_begin) ------------------ 404| 612k| } 405| | 406| 43.9k| graph->n += nv; 407| | 408| | /* Add attributes if necessary. This section is protected with 409| | * FINALLY_ENTER/EXIT so that the graph would not be accidentally 410| | * free upon error until it could be restored to a consistant state. */ 411| | 412| 43.9k| if (graph->attr) { ------------------ | Branch (412:9): [True: 0, False: 43.9k] ------------------ 413| 0| igraph_error_t err; 414| 0| IGRAPH_FINALLY_ENTER(); 415| 0| err = igraph_i_attribute_add_vertices(graph, nv, attr); 416| 0| if (err != IGRAPH_SUCCESS) { ------------------ | Branch (416:13): [True: 0, False: 0] ------------------ 417| | /* Restore original vertex count on failure */ 418| 0| graph->n = vc; 419| 0| igraph_vector_int_resize(&graph->os, vc + 1); /* shrinks */ 420| 0| igraph_vector_int_resize(&graph->is, vc + 1); /* shrinks */ 421| 0| } 422| 0| IGRAPH_FINALLY_EXIT(); 423| 0| if (err != IGRAPH_SUCCESS) { ------------------ | Branch (423:13): [True: 0, False: 0] ------------------ 424| 0| IGRAPH_ERROR("Cannot add vertices.", err); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 425| 0| } 426| 0| } 427| | 428| | /* modification successful, clear the cached properties of the graph. 429| | * 430| | * Adding one or more nodes does not change the following cached properties: 431| | * 432| | * - IGRAPH_PROP_HAS_LOOP 433| | * - IGRAPH_PROP_HAS_MULTI 434| | * - IGRAPH_PROP_HAS_MUTUAL 435| | * - IGRAPH_PROP_IS_DAG (adding a node does not create/destroy cycles) 436| | * - IGRAPH_PROP_IS_FOREST (same) 437| | * 438| | * Adding one or more nodes without any edges incident on them is sure to 439| | * make the graph disconnected (weakly or strongly), so we can keep the 440| | * connectivity-related properties if they are currently cached as false. 441| | * (Actually, even if they weren't cached as false, we could still set them 442| | * to false, but we don't have that functionality yet). The only exception 443| | * is when the graph had zero vertices and gained only one vertex, because 444| | * it then becomes connected. That's why we have the condition below in the 445| | * keep_when_false section. 446| | */ 447| 43.9k| igraph_i_property_cache_invalidate_conditionally( 448| 43.9k| graph, 449| | /* keep_always = */ 450| 43.9k| (1 << IGRAPH_PROP_HAS_LOOP) | 451| 43.9k| (1 << IGRAPH_PROP_HAS_MULTI) | 452| 43.9k| (1 << IGRAPH_PROP_HAS_MUTUAL) | 453| 43.9k| (1 << IGRAPH_PROP_IS_DAG) | 454| 43.9k| (1 << IGRAPH_PROP_IS_FOREST), 455| | /* keep_when_false = */ 456| 43.9k| igraph_vcount(graph) >= 2 ? ( ------------------ | Branch (456:9): [True: 41.9k, False: 1.99k] ------------------ 457| 41.9k| (1 << IGRAPH_PROP_IS_STRONGLY_CONNECTED) | 458| 41.9k| (1 << IGRAPH_PROP_IS_WEAKLY_CONNECTED) 459| 41.9k| ) : 0, 460| | /* keep_when_true = */ 461| 43.9k| 0 462| 43.9k| ); 463| | 464| 43.9k| return IGRAPH_SUCCESS; 465| 43.9k|} igraph_delete_vertices_idx: 642| 25.0k|) { 643| 25.0k| igraph_integer_t no_of_edges = igraph_ecount(graph); 644| 25.0k| igraph_integer_t no_of_nodes = igraph_vcount(graph); 645| 25.0k| igraph_vector_int_t edge_recoding, vertex_recoding; 646| 25.0k| igraph_vector_int_t *my_vertex_recoding = &vertex_recoding; 647| 25.0k| igraph_vit_t vit; 648| 25.0k| igraph_t newgraph; 649| 25.0k| igraph_integer_t i, j; 650| 25.0k| igraph_integer_t remaining_vertices, remaining_edges; 651| | 652| 25.0k| if (idx) { ------------------ | Branch (652:9): [True: 25.0k, False: 0] ------------------ 653| 25.0k| my_vertex_recoding = idx; 654| 25.0k| IGRAPH_CHECK(igraph_vector_int_resize(idx, no_of_nodes)); ------------------ | | 752| 25.0k| do { \ | | 753| 25.0k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 25.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 25.0k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 655| 25.0k| igraph_vector_int_null(idx); 656| 25.0k| } else { 657| 0| IGRAPH_VECTOR_INT_INIT_FINALLY(&vertex_recoding, no_of_nodes); ------------------ | | 124| 0| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 0| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 0| do { \ | | | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 0| * incorrect destructor function with the pointer */ \ | | | | 699| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 0| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 658| 0| } 659| | 660| 25.0k| IGRAPH_VECTOR_INT_INIT_FINALLY(&edge_recoding, no_of_edges); ------------------ | | 124| 25.0k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 25.0k| do { \ | | | | 753| 25.0k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 25.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 25.0k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 25.0k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 25.0k| do { \ | | | | 696| 25.0k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 25.0k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 25.0k| * incorrect destructor function with the pointer */ \ | | | | 699| 25.0k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 25.0k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 25.0k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 661| | 662| 25.0k| IGRAPH_CHECK(igraph_vit_create(graph, vertices, &vit)); ------------------ | | 752| 25.0k| do { \ | | 753| 25.0k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 25.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 25.0k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 663| 25.0k| IGRAPH_FINALLY(igraph_vit_destroy, &vit); ------------------ | | 695| 25.0k| do { \ | | 696| 25.0k| /* the following branch makes the compiler check the compatibility of \ | | 697| 25.0k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 25.0k| * incorrect destructor function with the pointer */ \ | | 699| 25.0k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 25.0k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 25.0k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 664| | 665| | /* mark the vertices to delete */ 666| 55.1k| for (; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit) ) { ------------------ | | 183| 55.1k|#define IGRAPH_VIT_END(vit) ((vit).pos >= (vit).end) ------------------ for (; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit) ) { ------------------ | | 171| 30.0k|#define IGRAPH_VIT_NEXT(vit) (++((vit).pos)) ------------------ | Branch (666:12): [True: 30.0k, False: 25.0k] ------------------ 667| 30.0k| igraph_integer_t vertex = IGRAPH_VIT_GET(vit); ------------------ | | 218| 30.0k| ((igraph_integer_t)(((vit).type == IGRAPH_VIT_RANGE) ? (vit).pos : \ | | ------------------ | | | Branch (218:25): [True: 0, False: 30.0k] | | ------------------ | | 219| 30.0k| VECTOR(*(vit).vec)[(vit).pos])) | | ------------------ | | | | 69| 30.0k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 668| 30.0k| if (vertex < 0 || vertex >= no_of_nodes) { ------------------ | Branch (668:13): [True: 0, False: 30.0k] | Branch (668:27): [True: 0, False: 30.0k] ------------------ 669| 0| IGRAPH_ERROR("Cannot delete vertices", IGRAPH_EINVVID); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 670| 0| } 671| 30.0k| VECTOR(*my_vertex_recoding)[vertex] = 1; ------------------ | | 69| 30.0k|#define VECTOR(v) ((v).stor_begin) ------------------ 672| 30.0k| } 673| | /* create vertex recoding vector */ 674| 172k| for (remaining_vertices = 0, i = 0; i < no_of_nodes; i++) { ------------------ | Branch (674:41): [True: 147k, False: 25.0k] ------------------ 675| 147k| if (VECTOR(*my_vertex_recoding)[i] == 0) { ------------------ | | 69| 147k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (675:13): [True: 117k, False: 30.0k] ------------------ 676| 117k| VECTOR(*my_vertex_recoding)[i] = remaining_vertices + 1; ------------------ | | 69| 117k|#define VECTOR(v) ((v).stor_begin) ------------------ 677| 117k| remaining_vertices++; 678| 117k| } else { 679| 30.0k| VECTOR(*my_vertex_recoding)[i] = 0; ------------------ | | 69| 30.0k|#define VECTOR(v) ((v).stor_begin) ------------------ 680| 30.0k| } 681| 147k| } 682| | /* create edge recoding vector */ 683| 283k| for (remaining_edges = 0, i = 0; i < no_of_edges; i++) { ------------------ | Branch (683:38): [True: 258k, False: 25.0k] ------------------ 684| 258k| igraph_integer_t from = VECTOR(graph->from)[i]; ------------------ | | 69| 258k|#define VECTOR(v) ((v).stor_begin) ------------------ 685| 258k| igraph_integer_t to = VECTOR(graph->to)[i]; ------------------ | | 69| 258k|#define VECTOR(v) ((v).stor_begin) ------------------ 686| 258k| if (VECTOR(*my_vertex_recoding)[from] != 0 && ------------------ | | 69| 258k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (686:13): [True: 170k, False: 88.3k] ------------------ 687| 258k| VECTOR(*my_vertex_recoding)[to ] != 0) { ------------------ | | 69| 170k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (687:13): [True: 170k, False: 133] ------------------ 688| 170k| VECTOR(edge_recoding)[i] = remaining_edges + 1; ------------------ | | 69| 170k|#define VECTOR(v) ((v).stor_begin) ------------------ 689| 170k| remaining_edges++; 690| 170k| } 691| 258k| } 692| | 693| | /* start creating the graph */ 694| 25.0k| newgraph.n = remaining_vertices; 695| 25.0k| newgraph.directed = graph->directed; 696| | 697| | /* allocate vectors */ 698| 25.0k| IGRAPH_VECTOR_INT_INIT_FINALLY(&newgraph.from, remaining_edges); ------------------ | | 124| 25.0k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 25.0k| do { \ | | | | 753| 25.0k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 25.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 25.0k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 25.0k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 25.0k| do { \ | | | | 696| 25.0k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 25.0k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 25.0k| * incorrect destructor function with the pointer */ \ | | | | 699| 25.0k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 25.0k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 25.0k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 699| 25.0k| IGRAPH_VECTOR_INT_INIT_FINALLY(&newgraph.to, remaining_edges); ------------------ | | 124| 25.0k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 25.0k| do { \ | | | | 753| 25.0k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 25.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 25.0k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 25.0k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 25.0k| do { \ | | | | 696| 25.0k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 25.0k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 25.0k| * incorrect destructor function with the pointer */ \ | | | | 699| 25.0k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 25.0k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 25.0k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 700| 25.0k| IGRAPH_VECTOR_INT_INIT_FINALLY(&newgraph.oi, remaining_edges); ------------------ | | 124| 25.0k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 25.0k| do { \ | | | | 753| 25.0k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 25.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 25.0k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 25.0k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 25.0k| do { \ | | | | 696| 25.0k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 25.0k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 25.0k| * incorrect destructor function with the pointer */ \ | | | | 699| 25.0k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 25.0k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 25.0k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 701| 25.0k| IGRAPH_VECTOR_INT_INIT_FINALLY(&newgraph.ii, remaining_edges); ------------------ | | 124| 25.0k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 25.0k| do { \ | | | | 753| 25.0k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 25.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 25.0k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 25.0k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 25.0k| do { \ | | | | 696| 25.0k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 25.0k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 25.0k| * incorrect destructor function with the pointer */ \ | | | | 699| 25.0k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 25.0k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 25.0k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 702| 25.0k| IGRAPH_VECTOR_INT_INIT_FINALLY(&newgraph.os, remaining_vertices + 1); ------------------ | | 124| 25.0k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 25.0k| do { \ | | | | 753| 25.0k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 25.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 25.0k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 25.0k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 25.0k| do { \ | | | | 696| 25.0k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 25.0k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 25.0k| * incorrect destructor function with the pointer */ \ | | | | 699| 25.0k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 25.0k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 25.0k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 703| 25.0k| IGRAPH_VECTOR_INT_INIT_FINALLY(&newgraph.is, remaining_vertices + 1); ------------------ | | 124| 25.0k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 25.0k| do { \ | | | | 753| 25.0k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 25.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 25.0k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 25.0k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 25.0k| do { \ | | | | 696| 25.0k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 25.0k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 25.0k| * incorrect destructor function with the pointer */ \ | | | | 699| 25.0k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 25.0k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 25.0k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 704| | 705| | /* Add the edges */ 706| 283k| for (i = 0, j = 0; j < remaining_edges; i++) { ------------------ | Branch (706:24): [True: 258k, False: 25.0k] ------------------ 707| 258k| if (VECTOR(edge_recoding)[i] > 0) { ------------------ | | 69| 258k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (707:13): [True: 170k, False: 88.4k] ------------------ 708| 170k| igraph_integer_t from = VECTOR(graph->from)[i]; ------------------ | | 69| 170k|#define VECTOR(v) ((v).stor_begin) ------------------ 709| 170k| igraph_integer_t to = VECTOR(graph->to )[i]; ------------------ | | 69| 170k|#define VECTOR(v) ((v).stor_begin) ------------------ 710| 170k| VECTOR(newgraph.from)[j] = VECTOR(*my_vertex_recoding)[from] - 1; ------------------ | | 69| 170k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(newgraph.from)[j] = VECTOR(*my_vertex_recoding)[from] - 1; ------------------ | | 69| 170k|#define VECTOR(v) ((v).stor_begin) ------------------ 711| 170k| VECTOR(newgraph.to )[j] = VECTOR(*my_vertex_recoding)[to] - 1; ------------------ | | 69| 170k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(newgraph.to )[j] = VECTOR(*my_vertex_recoding)[to] - 1; ------------------ | | 69| 170k|#define VECTOR(v) ((v).stor_begin) ------------------ 712| 170k| j++; 713| 170k| } 714| 258k| } 715| | 716| | /* update oi & ii */ 717| 25.0k| IGRAPH_CHECK(igraph_vector_int_pair_order(&newgraph.from, &newgraph.to, &newgraph.oi, ------------------ | | 752| 25.0k| do { \ | | 753| 25.0k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 25.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 25.0k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 718| 25.0k| remaining_vertices)); 719| 25.0k| IGRAPH_CHECK(igraph_vector_int_pair_order(&newgraph.to, &newgraph.from, &newgraph.ii, ------------------ | | 752| 25.0k| do { \ | | 753| 25.0k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 25.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 25.0k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 720| 25.0k| remaining_vertices)); 721| | 722| 25.0k| IGRAPH_CHECK(igraph_i_create_start_vectors(&newgraph.os, &newgraph.from, ------------------ | | 752| 25.0k| do { \ | | 753| 25.0k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 25.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 25.0k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 723| 25.0k| &newgraph.oi, remaining_vertices)); 724| 25.0k| IGRAPH_CHECK(igraph_i_create_start_vectors(&newgraph.is, &newgraph.to, ------------------ | | 752| 25.0k| do { \ | | 753| 25.0k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 25.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 25.0k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 725| 25.0k| &newgraph.ii, remaining_vertices)); 726| | 727| 25.0k| newgraph.cache = IGRAPH_CALLOC(1, igraph_i_property_cache_t); ------------------ | | 32| 25.0k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [Folded - Ignored] | | ------------------ ------------------ 728| 25.0k| IGRAPH_CHECK_OOM(newgraph.cache, "Cannot delete vertices."); ------------------ | | 807| 25.0k| do { \ | | 808| 25.0k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 25.0k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 729| 25.0k| IGRAPH_FINALLY(igraph_free, newgraph.cache); ------------------ | | 695| 25.0k| do { \ | | 696| 25.0k| /* the following branch makes the compiler check the compatibility of \ | | 697| 25.0k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 25.0k| * incorrect destructor function with the pointer */ \ | | 699| 25.0k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 25.0k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 25.0k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 730| 25.0k| IGRAPH_CHECK(igraph_i_property_cache_init(newgraph.cache)); ------------------ | | 752| 25.0k| do { \ | | 753| 25.0k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 25.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 25.0k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 731| 25.0k| IGRAPH_FINALLY(igraph_i_property_cache_destroy, newgraph.cache); ------------------ | | 695| 25.0k| do { \ | | 696| 25.0k| /* the following branch makes the compiler check the compatibility of \ | | 697| 25.0k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 25.0k| * incorrect destructor function with the pointer */ \ | | 699| 25.0k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 25.0k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 25.0k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 732| | 733| | /* attributes */ 734| 25.0k| IGRAPH_I_ATTRIBUTE_COPY(&newgraph, graph, ------------------ | | 31| 25.0k|#define IGRAPH_I_ATTRIBUTE_COPY(to,from,ga,va,ea) do { \ | | 32| 25.0k| igraph_error_t igraph_i_ret2=IGRAPH_SUCCESS; \ | | 33| 25.0k| if ((from)->attr) { \ | | ------------------ | | | Branch (33:13): [True: 0, False: 25.0k] | | ------------------ | | 34| 0| IGRAPH_CHECK(igraph_i_ret2=igraph_i_attribute_copy((to),(from),(ga),(va),(ea))); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 35| 25.0k| } else { \ | | 36| 25.0k| (to)->attr = NULL; \ | | 37| 25.0k| } \ | | 38| 25.0k| if (igraph_i_ret2 != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (38:13): [True: 0, False: 25.0k] | | ------------------ | | 39| 0| IGRAPH_ERROR("", igraph_i_ret2); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 40| 0| } \ | | 41| 25.0k| } while(0) | | ------------------ | | | Branch (41:13): [Folded - Ignored] | | ------------------ ------------------ 735| 25.0k| /*graph=*/ 1, /*vertex=*/0, /*edge=*/0); 736| | 737| | /* at this point igraph_destroy can take over the responsibility of 738| | * deallocating the graph */ 739| 25.0k| IGRAPH_FINALLY_CLEAN(8); /* 2 for the property cache, 6 for the vectors */ 740| 25.0k| IGRAPH_FINALLY(igraph_destroy, &newgraph); ------------------ | | 695| 25.0k| do { \ | | 696| 25.0k| /* the following branch makes the compiler check the compatibility of \ | | 697| 25.0k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 25.0k| * incorrect destructor function with the pointer */ \ | | 699| 25.0k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 25.0k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 25.0k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 741| | 742| 25.0k| if (newgraph.attr) { ------------------ | Branch (742:9): [True: 0, False: 25.0k] ------------------ 743| 0| igraph_vector_int_t iidx; 744| 0| IGRAPH_VECTOR_INT_INIT_FINALLY(&iidx, remaining_vertices); ------------------ | | 124| 0| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 0| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 0| do { \ | | | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 0| * incorrect destructor function with the pointer */ \ | | | | 699| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 0| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 745| 0| for (i = 0; i < no_of_nodes; i++) { ------------------ | Branch (745:21): [True: 0, False: 0] ------------------ 746| 0| igraph_integer_t jj = VECTOR(*my_vertex_recoding)[i]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 747| 0| if (jj != 0) { ------------------ | Branch (747:17): [True: 0, False: 0] ------------------ 748| 0| VECTOR(iidx)[ jj - 1 ] = i; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 749| 0| } 750| 0| } 751| 0| IGRAPH_CHECK(igraph_i_attribute_permute_vertices(graph, ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 752| 0| &newgraph, 753| 0| &iidx)); 754| 0| IGRAPH_CHECK(igraph_vector_int_resize(&iidx, remaining_edges)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 755| 0| for (i = 0; i < no_of_edges; i++) { ------------------ | Branch (755:21): [True: 0, False: 0] ------------------ 756| 0| igraph_integer_t jj = VECTOR(edge_recoding)[i]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 757| 0| if (jj != 0) { ------------------ | Branch (757:17): [True: 0, False: 0] ------------------ 758| 0| VECTOR(iidx)[ jj - 1 ] = i; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 759| 0| } 760| 0| } 761| 0| IGRAPH_CHECK(igraph_i_attribute_permute_edges(graph, &newgraph, &iidx)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 762| 0| igraph_vector_int_destroy(&iidx); 763| 0| IGRAPH_FINALLY_CLEAN(1); 764| 0| } 765| | 766| 25.0k| igraph_vit_destroy(&vit); 767| 25.0k| igraph_vector_int_destroy(&edge_recoding); 768| 25.0k| igraph_destroy(graph); 769| 25.0k| *graph = newgraph; 770| | 771| 25.0k| IGRAPH_FINALLY_CLEAN(3); 772| | 773| | /* TODO: this is duplicate */ 774| 25.0k| if (invidx) { ------------------ | Branch (774:9): [True: 25.0k, False: 0] ------------------ 775| 25.0k| IGRAPH_CHECK(igraph_vector_int_resize(invidx, remaining_vertices)); ------------------ | | 752| 25.0k| do { \ | | 753| 25.0k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 25.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 25.0k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 776| 172k| for (i = 0; i < no_of_nodes; i++) { ------------------ | Branch (776:21): [True: 147k, False: 25.0k] ------------------ 777| 147k| igraph_integer_t newid = VECTOR(*my_vertex_recoding)[i]; ------------------ | | 69| 147k|#define VECTOR(v) ((v).stor_begin) ------------------ 778| 147k| if (newid != 0) { ------------------ | Branch (778:17): [True: 117k, False: 30.0k] ------------------ 779| 117k| VECTOR(*invidx)[newid - 1] = i; ------------------ | | 69| 117k|#define VECTOR(v) ((v).stor_begin) ------------------ 780| 117k| } 781| 147k| } 782| 25.0k| } 783| | 784| 25.0k| if (!idx) { ------------------ | Branch (784:9): [True: 0, False: 25.0k] ------------------ 785| 0| igraph_vector_int_destroy(my_vertex_recoding); 786| 0| IGRAPH_FINALLY_CLEAN(1); 787| 0| } 788| | 789| | /* modification successful, clear the cached properties of the graph. 790| | * 791| | * Deleting one or more vertices cannot make a directed acyclic graph cyclic, 792| | * or an undirected forest into a cyclic graph, so we keep those flags if 793| | * they are cached as true. 794| | * 795| | * Also, if the graph had no loop edges before the deletion, it will have 796| | * no loop edges after the deletion either. The same applies to reciprocal 797| | * edges or multiple edges as well. 798| | */ 799| 25.0k| igraph_i_property_cache_invalidate_conditionally( 800| 25.0k| graph, 801| 25.0k| /* keep_always = */ 0, 802| | /* keep_when_false = */ 803| 25.0k| (1 << IGRAPH_PROP_HAS_LOOP) | 804| 25.0k| (1 << IGRAPH_PROP_HAS_MULTI) | 805| 25.0k| (1 << IGRAPH_PROP_HAS_MUTUAL), 806| | /* keep_when_true = */ 807| 25.0k| (1 << IGRAPH_PROP_IS_DAG) | 808| 25.0k| (1 << IGRAPH_PROP_IS_FOREST) 809| 25.0k| ); 810| | 811| 25.0k| return IGRAPH_SUCCESS; 812| 25.0k|} igraph_vcount: 824| 1.52M|igraph_integer_t igraph_vcount(const igraph_t *graph) { 825| 1.52M| return graph->n; 826| 1.52M|} igraph_ecount: 838| 3.37M|igraph_integer_t igraph_ecount(const igraph_t *graph) { 839| 3.37M| return igraph_vector_int_size(&graph->from); 840| 3.37M|} igraph_neighbors: 876| 530k| igraph_neimode_t mode) { 877| 530k| if (!igraph_is_directed(graph) || mode == IGRAPH_ALL) { ------------------ | Branch (877:9): [True: 22.3k, False: 508k] | Branch (877:39): [True: 0, False: 508k] ------------------ 878| 22.3k| return igraph_i_neighbors(graph, neis, pnode, mode, IGRAPH_LOOPS_TWICE, IGRAPH_MULTIPLE); 879| 508k| } else { 880| 508k| return igraph_i_neighbors(graph, neis, pnode, mode, IGRAPH_LOOPS_ONCE, IGRAPH_MULTIPLE); 881| 508k| } 882| 530k|} igraph_i_neighbors: 885| 530k| igraph_neimode_t mode, igraph_loops_t loops, igraph_multiple_t multiple) { 886| 530k|#define DEDUPLICATE_IF_NEEDED(vertex, n) \ 887| 530k| if (should_filter_duplicates) { \ 888| 530k| if ( \ 889| 530k| (loops == IGRAPH_NO_LOOPS && vertex == pnode) || \ 890| 530k| (loops == IGRAPH_LOOPS_ONCE && vertex == pnode && last_added == pnode) \ 891| 530k| ) { \ 892| 530k| length -= n; \ 893| 530k| if (loops == IGRAPH_LOOPS_ONCE) { \ 894| 530k| last_added = -1; \ 895| 530k| } \ 896| 530k| continue; \ 897| 530k| } else if (multiple == IGRAPH_NO_MULTIPLE && vertex == last_added) { \ 898| 530k| length -= n; \ 899| 530k| continue; \ 900| 530k| } else { \ 901| 530k| last_added = vertex; \ 902| 530k| } \ 903| 530k| } 904| | 905| 530k| igraph_integer_t length = 0, idx = 0; 906| 530k| igraph_integer_t i, j; 907| | 908| 530k| igraph_integer_t node = pnode; 909| 530k| igraph_integer_t last_added = -1; 910| 530k| igraph_bool_t should_filter_duplicates; 911| | 912| 530k| if (node < 0 || node > igraph_vcount(graph) - 1) { ------------------ | Branch (912:9): [True: 0, False: 530k] | Branch (912:21): [True: 0, False: 530k] ------------------ 913| 0| IGRAPH_ERROR("Given vertex is not in the graph.", IGRAPH_EINVVID); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 914| 0| } 915| 530k| if (mode != IGRAPH_OUT && mode != IGRAPH_IN && ------------------ | Branch (915:9): [True: 165k, False: 365k] | Branch (915:31): [True: 22.3k, False: 143k] ------------------ 916| 530k| mode != IGRAPH_ALL) { ------------------ | Branch (916:13): [True: 0, False: 22.3k] ------------------ 917| 0| IGRAPH_ERROR("Mode should be either IGRAPH_OUT, IGRAPH_IN or IGRAPH_ALL.", IGRAPH_EINVMODE); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 918| 0| } 919| | 920| 530k| if (!igraph_is_directed(graph)) { ------------------ | Branch (920:9): [True: 22.3k, False: 508k] ------------------ 921| 22.3k| mode = IGRAPH_ALL; 922| 22.3k| } 923| | 924| 530k| if (mode != IGRAPH_ALL && loops == IGRAPH_LOOPS_TWICE) { ------------------ | Branch (924:9): [True: 508k, False: 22.3k] | Branch (924:31): [True: 0, False: 508k] ------------------ 925| 0| IGRAPH_ERROR("For a directed graph (with directions not ignored), " ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 926| 0| "IGRAPH_LOOPS_TWICE does not make sense.\n", IGRAPH_EINVAL); 927| 0| } 928| | /* Calculate needed space first & allocate it */ 929| | /* Note that 'mode' is treated as a bit field here; it's okay because 930| | * IGRAPH_ALL = IGRAPH_IN | IGRAPH_OUT, bit-wise */ 931| 530k| if (mode & IGRAPH_OUT) { ------------------ | Branch (931:9): [True: 387k, False: 143k] ------------------ 932| 387k| length += (VECTOR(graph->os)[node + 1] - VECTOR(graph->os)[node]); ------------------ | | 69| 387k|#define VECTOR(v) ((v).stor_begin) ------------------ length += (VECTOR(graph->os)[node + 1] - VECTOR(graph->os)[node]); ------------------ | | 69| 387k|#define VECTOR(v) ((v).stor_begin) ------------------ 933| 387k| } 934| 530k| if (mode & IGRAPH_IN) { ------------------ | Branch (934:9): [True: 165k, False: 365k] ------------------ 935| 165k| length += (VECTOR(graph->is)[node + 1] - VECTOR(graph->is)[node]); ------------------ | | 69| 165k|#define VECTOR(v) ((v).stor_begin) ------------------ length += (VECTOR(graph->is)[node + 1] - VECTOR(graph->is)[node]); ------------------ | | 69| 165k|#define VECTOR(v) ((v).stor_begin) ------------------ 936| 165k| } 937| | 938| 530k| IGRAPH_CHECK(igraph_vector_int_resize(neis, length)); ------------------ | | 752| 530k| do { \ | | 753| 530k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 530k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 530k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 530k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 530k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 939| | 940| | /* The loops below produce an ordering what is consistent with the 941| | * ordering returned by igraph_neighbors(), and this should be preserved. 942| | * We are dealing with two sorted lists; one for the successors and one 943| | * for the predecessors. If we have requested only one of them, we have 944| | * an easy job. If we have requested both, we need to merge the two lists 945| | * to ensure that the output is sorted by the vertex IDs of the "other" 946| | * endpoint of the affected edges. We don't need to merge if the graph 947| | * is undirected, because in that case the data structure guarantees that 948| | * the "out-edges" contain only (u, v) pairs where u <= v and the 949| | * "in-edges" contains the rest, so the result is sorted even without 950| | * merging. */ 951| 530k| if (!igraph_is_directed(graph) || mode != IGRAPH_ALL) { ------------------ | Branch (951:9): [True: 22.3k, False: 508k] | Branch (951:39): [True: 508k, False: 0] ------------------ 952| | /* graph is undirected or we did not ask for both directions in a 953| | * directed graph; this is the easy case */ 954| | 955| 530k| should_filter_duplicates = !(multiple == IGRAPH_MULTIPLE && ------------------ | Branch (955:38): [True: 530k, False: 0] ------------------ 956| 530k| ((!igraph_is_directed(graph) && loops == IGRAPH_LOOPS_TWICE) || ------------------ | Branch (956:19): [True: 22.3k, False: 508k] | Branch (956:49): [True: 22.3k, False: 0] ------------------ 957| 530k| (igraph_is_directed(graph) && loops != IGRAPH_NO_LOOPS))); ------------------ | Branch (957:19): [True: 508k, False: 0] | Branch (957:48): [True: 508k, False: 0] ------------------ 958| | 959| 530k| if (mode & IGRAPH_OUT) { ------------------ | Branch (959:13): [True: 387k, False: 143k] ------------------ 960| 387k| j = VECTOR(graph->os)[node + 1]; ------------------ | | 69| 387k|#define VECTOR(v) ((v).stor_begin) ------------------ 961| 988k| for (i = VECTOR(graph->os)[node]; i < j; i++) { ------------------ | | 69| 387k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (961:47): [True: 600k, False: 387k] ------------------ 962| 600k| igraph_integer_t to = VECTOR(graph->to)[ VECTOR(graph->oi)[i] ]; ------------------ | | 69| 600k|#define VECTOR(v) ((v).stor_begin) ------------------ igraph_integer_t to = VECTOR(graph->to)[ VECTOR(graph->oi)[i] ]; ------------------ | | 69| 600k|#define VECTOR(v) ((v).stor_begin) ------------------ 963| 600k| DEDUPLICATE_IF_NEEDED(to, 1); ------------------ | | 887| 600k| if (should_filter_duplicates) { \ | | ------------------ | | | Branch (887:9): [True: 0, False: 600k] | | ------------------ | | 888| 0| if ( \ | | 889| 0| (loops == IGRAPH_NO_LOOPS && vertex == pnode) || \ | | ------------------ | | | Branch (889:14): [True: 0, False: 0] | | | Branch (889:42): [True: 0, False: 0] | | ------------------ | | 890| 0| (loops == IGRAPH_LOOPS_ONCE && vertex == pnode && last_added == pnode) \ | | ------------------ | | | Branch (890:14): [True: 0, False: 0] | | | Branch (890:44): [True: 0, False: 0] | | | Branch (890:63): [True: 0, False: 0] | | ------------------ | | 891| 0| ) { \ | | 892| 0| length -= n; \ | | 893| 0| if (loops == IGRAPH_LOOPS_ONCE) { \ | | ------------------ | | | Branch (893:17): [True: 0, False: 0] | | ------------------ | | 894| 0| last_added = -1; \ | | 895| 0| } \ | | 896| 0| continue; \ | | 897| 0| } else if (multiple == IGRAPH_NO_MULTIPLE && vertex == last_added) { \ | | ------------------ | | | Branch (897:20): [True: 0, False: 0] | | | Branch (897:54): [True: 0, False: 0] | | ------------------ | | 898| 0| length -= n; \ | | 899| 0| continue; \ | | 900| 0| } else { \ | | 901| 0| last_added = vertex; \ | | 902| 0| } \ | | 903| 0| } ------------------ 964| 600k| VECTOR(*neis)[idx++] = to; ------------------ | | 69| 600k|#define VECTOR(v) ((v).stor_begin) ------------------ 965| 600k| } 966| 387k| } 967| | 968| 530k| if (mode & IGRAPH_IN) { ------------------ | Branch (968:13): [True: 165k, False: 365k] ------------------ 969| 165k| j = VECTOR(graph->is)[node + 1]; ------------------ | | 69| 165k|#define VECTOR(v) ((v).stor_begin) ------------------ 970| 591k| for (i = VECTOR(graph->is)[node]; i < j; i++) { ------------------ | | 69| 165k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (970:47): [True: 426k, False: 165k] ------------------ 971| 426k| igraph_integer_t from = VECTOR(graph->from)[ VECTOR(graph->ii)[i] ]; ------------------ | | 69| 426k|#define VECTOR(v) ((v).stor_begin) ------------------ igraph_integer_t from = VECTOR(graph->from)[ VECTOR(graph->ii)[i] ]; ------------------ | | 69| 426k|#define VECTOR(v) ((v).stor_begin) ------------------ 972| 426k| DEDUPLICATE_IF_NEEDED(from, 1); ------------------ | | 887| 426k| if (should_filter_duplicates) { \ | | ------------------ | | | Branch (887:9): [True: 0, False: 426k] | | ------------------ | | 888| 0| if ( \ | | 889| 0| (loops == IGRAPH_NO_LOOPS && vertex == pnode) || \ | | ------------------ | | | Branch (889:14): [True: 0, False: 0] | | | Branch (889:42): [True: 0, False: 0] | | ------------------ | | 890| 0| (loops == IGRAPH_LOOPS_ONCE && vertex == pnode && last_added == pnode) \ | | ------------------ | | | Branch (890:14): [True: 0, False: 0] | | | Branch (890:44): [True: 0, False: 0] | | | Branch (890:63): [True: 0, False: 0] | | ------------------ | | 891| 0| ) { \ | | 892| 0| length -= n; \ | | 893| 0| if (loops == IGRAPH_LOOPS_ONCE) { \ | | ------------------ | | | Branch (893:17): [True: 0, False: 0] | | ------------------ | | 894| 0| last_added = -1; \ | | 895| 0| } \ | | 896| 0| continue; \ | | 897| 0| } else if (multiple == IGRAPH_NO_MULTIPLE && vertex == last_added) { \ | | ------------------ | | | Branch (897:20): [True: 0, False: 0] | | | Branch (897:54): [True: 0, False: 0] | | ------------------ | | 898| 0| length -= n; \ | | 899| 0| continue; \ | | 900| 0| } else { \ | | 901| 0| last_added = vertex; \ | | 902| 0| } \ | | 903| 0| } ------------------ 973| 426k| VECTOR(*neis)[idx++] = from; ------------------ | | 69| 426k|#define VECTOR(v) ((v).stor_begin) ------------------ 974| 426k| } 975| 165k| } 976| 530k| } else { 977| | /* Both in- and out- neighbors in a directed graph, 978| | we need to merge the two 'vectors' so the result is 979| | correctly ordered. */ 980| 0| igraph_integer_t j1 = VECTOR(graph->os)[node + 1]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 981| 0| igraph_integer_t j2 = VECTOR(graph->is)[node + 1]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 982| 0| igraph_integer_t i1 = VECTOR(graph->os)[node]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 983| 0| igraph_integer_t i2 = VECTOR(graph->is)[node]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 984| 0| igraph_integer_t eid1, eid2; 985| 0| igraph_integer_t n1, n2; 986| | 987| 0| should_filter_duplicates = !(multiple == IGRAPH_MULTIPLE && ------------------ | Branch (987:38): [True: 0, False: 0] ------------------ 988| 0| loops == IGRAPH_LOOPS_TWICE); ------------------ | Branch (988:17): [True: 0, False: 0] ------------------ 989| | 990| 0| while (i1 < j1 && i2 < j2) { ------------------ | Branch (990:16): [True: 0, False: 0] | Branch (990:27): [True: 0, False: 0] ------------------ 991| 0| eid1 = VECTOR(graph->oi)[i1]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 992| 0| eid2 = VECTOR(graph->ii)[i2]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 993| 0| n1 = VECTOR(graph->to)[eid1]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 994| 0| n2 = VECTOR(graph->from)[eid2]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 995| 0| if (n1 < n2) { ------------------ | Branch (995:17): [True: 0, False: 0] ------------------ 996| 0| i1++; 997| 0| DEDUPLICATE_IF_NEEDED(n1, 1); ------------------ | | 887| 0| if (should_filter_duplicates) { \ | | ------------------ | | | Branch (887:9): [True: 0, False: 0] | | ------------------ | | 888| 0| if ( \ | | 889| 0| (loops == IGRAPH_NO_LOOPS && vertex == pnode) || \ | | ------------------ | | | Branch (889:14): [True: 0, False: 0] | | | Branch (889:42): [True: 0, False: 0] | | ------------------ | | 890| 0| (loops == IGRAPH_LOOPS_ONCE && vertex == pnode && last_added == pnode) \ | | ------------------ | | | Branch (890:14): [True: 0, False: 0] | | | Branch (890:44): [True: 0, False: 0] | | | Branch (890:63): [True: 0, False: 0] | | ------------------ | | 891| 0| ) { \ | | 892| 0| length -= n; \ | | 893| 0| if (loops == IGRAPH_LOOPS_ONCE) { \ | | ------------------ | | | Branch (893:17): [True: 0, False: 0] | | ------------------ | | 894| 0| last_added = -1; \ | | 895| 0| } \ | | 896| 0| continue; \ | | 897| 0| } else if (multiple == IGRAPH_NO_MULTIPLE && vertex == last_added) { \ | | ------------------ | | | Branch (897:20): [True: 0, False: 0] | | | Branch (897:54): [True: 0, False: 0] | | ------------------ | | 898| 0| length -= n; \ | | 899| 0| continue; \ | | 900| 0| } else { \ | | 901| 0| last_added = vertex; \ | | 902| 0| } \ | | 903| 0| } ------------------ 998| 0| VECTOR(*neis)[idx++] = n1; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 999| 0| } else if (n1 > n2) { ------------------ | Branch (999:24): [True: 0, False: 0] ------------------ 1000| 0| i2++; 1001| 0| DEDUPLICATE_IF_NEEDED(n2, 1); ------------------ | | 887| 0| if (should_filter_duplicates) { \ | | ------------------ | | | Branch (887:9): [True: 0, False: 0] | | ------------------ | | 888| 0| if ( \ | | 889| 0| (loops == IGRAPH_NO_LOOPS && vertex == pnode) || \ | | ------------------ | | | Branch (889:14): [True: 0, False: 0] | | | Branch (889:42): [True: 0, False: 0] | | ------------------ | | 890| 0| (loops == IGRAPH_LOOPS_ONCE && vertex == pnode && last_added == pnode) \ | | ------------------ | | | Branch (890:14): [True: 0, False: 0] | | | Branch (890:44): [True: 0, False: 0] | | | Branch (890:63): [True: 0, False: 0] | | ------------------ | | 891| 0| ) { \ | | 892| 0| length -= n; \ | | 893| 0| if (loops == IGRAPH_LOOPS_ONCE) { \ | | ------------------ | | | Branch (893:17): [True: 0, False: 0] | | ------------------ | | 894| 0| last_added = -1; \ | | 895| 0| } \ | | 896| 0| continue; \ | | 897| 0| } else if (multiple == IGRAPH_NO_MULTIPLE && vertex == last_added) { \ | | ------------------ | | | Branch (897:20): [True: 0, False: 0] | | | Branch (897:54): [True: 0, False: 0] | | ------------------ | | 898| 0| length -= n; \ | | 899| 0| continue; \ | | 900| 0| } else { \ | | 901| 0| last_added = vertex; \ | | 902| 0| } \ | | 903| 0| } ------------------ 1002| 0| VECTOR(*neis)[idx++] = n2; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 1003| 0| } else { 1004| 0| i1++; 1005| 0| i2++; 1006| 0| DEDUPLICATE_IF_NEEDED(n1, 2); ------------------ | | 887| 0| if (should_filter_duplicates) { \ | | ------------------ | | | Branch (887:9): [True: 0, False: 0] | | ------------------ | | 888| 0| if ( \ | | 889| 0| (loops == IGRAPH_NO_LOOPS && vertex == pnode) || \ | | ------------------ | | | Branch (889:14): [True: 0, False: 0] | | | Branch (889:42): [True: 0, False: 0] | | ------------------ | | 890| 0| (loops == IGRAPH_LOOPS_ONCE && vertex == pnode && last_added == pnode) \ | | ------------------ | | | Branch (890:14): [True: 0, False: 0] | | | Branch (890:44): [True: 0, False: 0] | | | Branch (890:63): [True: 0, False: 0] | | ------------------ | | 891| 0| ) { \ | | 892| 0| length -= n; \ | | 893| 0| if (loops == IGRAPH_LOOPS_ONCE) { \ | | ------------------ | | | Branch (893:17): [True: 0, False: 0] | | ------------------ | | 894| 0| last_added = -1; \ | | 895| 0| } \ | | 896| 0| continue; \ | | 897| 0| } else if (multiple == IGRAPH_NO_MULTIPLE && vertex == last_added) { \ | | ------------------ | | | Branch (897:20): [True: 0, False: 0] | | | Branch (897:54): [True: 0, False: 0] | | ------------------ | | 898| 0| length -= n; \ | | 899| 0| continue; \ | | 900| 0| } else { \ | | 901| 0| last_added = vertex; \ | | 902| 0| } \ | | 903| 0| } ------------------ 1007| 0| VECTOR(*neis)[idx++] = n1; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 1008| 0| if (should_filter_duplicates && ((loops == IGRAPH_LOOPS_ONCE && n1 == pnode && last_added == pnode) || ------------------ | Branch (1008:21): [True: 0, False: 0] | Branch (1008:51): [True: 0, False: 0] | Branch (1008:81): [True: 0, False: 0] | Branch (1008:96): [True: 0, False: 0] ------------------ 1009| 0| (multiple == IGRAPH_NO_MULTIPLE))) { ------------------ | Branch (1009:25): [True: 0, False: 0] ------------------ 1010| 0| length--; 1011| 0| if (loops == IGRAPH_LOOPS_ONCE) { ------------------ | Branch (1011:25): [True: 0, False: 0] ------------------ 1012| 0| last_added = -1; 1013| 0| } 1014| 0| continue; 1015| 0| } 1016| 0| VECTOR(*neis)[idx++] = n2; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 1017| 0| } 1018| 0| } 1019| | 1020| 0| while (i1 < j1) { ------------------ | Branch (1020:16): [True: 0, False: 0] ------------------ 1021| 0| eid1 = VECTOR(graph->oi)[i1++]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 1022| 0| igraph_integer_t to = VECTOR(graph->to)[eid1]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 1023| 0| DEDUPLICATE_IF_NEEDED(to, 1); ------------------ | | 887| 0| if (should_filter_duplicates) { \ | | ------------------ | | | Branch (887:9): [True: 0, False: 0] | | ------------------ | | 888| 0| if ( \ | | 889| 0| (loops == IGRAPH_NO_LOOPS && vertex == pnode) || \ | | ------------------ | | | Branch (889:14): [True: 0, False: 0] | | | Branch (889:42): [True: 0, False: 0] | | ------------------ | | 890| 0| (loops == IGRAPH_LOOPS_ONCE && vertex == pnode && last_added == pnode) \ | | ------------------ | | | Branch (890:14): [True: 0, False: 0] | | | Branch (890:44): [True: 0, False: 0] | | | Branch (890:63): [True: 0, False: 0] | | ------------------ | | 891| 0| ) { \ | | 892| 0| length -= n; \ | | 893| 0| if (loops == IGRAPH_LOOPS_ONCE) { \ | | ------------------ | | | Branch (893:17): [True: 0, False: 0] | | ------------------ | | 894| 0| last_added = -1; \ | | 895| 0| } \ | | 896| 0| continue; \ | | 897| 0| } else if (multiple == IGRAPH_NO_MULTIPLE && vertex == last_added) { \ | | ------------------ | | | Branch (897:20): [True: 0, False: 0] | | | Branch (897:54): [True: 0, False: 0] | | ------------------ | | 898| 0| length -= n; \ | | 899| 0| continue; \ | | 900| 0| } else { \ | | 901| 0| last_added = vertex; \ | | 902| 0| } \ | | 903| 0| } ------------------ 1024| 0| VECTOR(*neis)[idx++] = to; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 1025| 0| } 1026| | 1027| 0| while (i2 < j2) { ------------------ | Branch (1027:16): [True: 0, False: 0] ------------------ 1028| 0| eid2 = VECTOR(graph->ii)[i2++]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 1029| 0| igraph_integer_t from = VECTOR(graph->from)[eid2]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 1030| 0| DEDUPLICATE_IF_NEEDED(from, 1); ------------------ | | 887| 0| if (should_filter_duplicates) { \ | | ------------------ | | | Branch (887:9): [True: 0, False: 0] | | ------------------ | | 888| 0| if ( \ | | 889| 0| (loops == IGRAPH_NO_LOOPS && vertex == pnode) || \ | | ------------------ | | | Branch (889:14): [True: 0, False: 0] | | | Branch (889:42): [True: 0, False: 0] | | ------------------ | | 890| 0| (loops == IGRAPH_LOOPS_ONCE && vertex == pnode && last_added == pnode) \ | | ------------------ | | | Branch (890:14): [True: 0, False: 0] | | | Branch (890:44): [True: 0, False: 0] | | | Branch (890:63): [True: 0, False: 0] | | ------------------ | | 891| 0| ) { \ | | 892| 0| length -= n; \ | | 893| 0| if (loops == IGRAPH_LOOPS_ONCE) { \ | | ------------------ | | | Branch (893:17): [True: 0, False: 0] | | ------------------ | | 894| 0| last_added = -1; \ | | 895| 0| } \ | | 896| 0| continue; \ | | 897| 0| } else if (multiple == IGRAPH_NO_MULTIPLE && vertex == last_added) { \ | | ------------------ | | | Branch (897:20): [True: 0, False: 0] | | | Branch (897:54): [True: 0, False: 0] | | ------------------ | | 898| 0| length -= n; \ | | 899| 0| continue; \ | | 900| 0| } else { \ | | 901| 0| last_added = vertex; \ | | 902| 0| } \ | | 903| 0| } ------------------ 1031| 0| VECTOR(*neis)[idx++] = from; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 1032| 0| } 1033| | 1034| 0| } 1035| 530k| IGRAPH_CHECK(igraph_vector_int_resize(neis, length)); ------------------ | | 752| 530k| do { \ | | 753| 530k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 530k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 530k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 530k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 530k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1036| | 1037| 530k| return IGRAPH_SUCCESS; 1038| 530k|#undef DEDUPLICATE_IF_NEEDED 1039| 530k|} igraph_is_directed: 1104| 6.44M|igraph_bool_t igraph_is_directed(const igraph_t *graph) { 1105| 6.44M| return graph->directed; 1106| 6.44M|} igraph_degree: 1213| 61.2k| igraph_neimode_t mode, igraph_bool_t loops) { 1214| | 1215| 61.2k| igraph_integer_t nodes_to_calc; 1216| 61.2k| igraph_integer_t i, j; 1217| 61.2k| igraph_vit_t vit; 1218| | 1219| 61.2k| IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit)); ------------------ | | 752| 61.2k| do { \ | | 753| 61.2k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 61.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 61.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 61.2k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 61.2k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1220| 61.2k| IGRAPH_FINALLY(igraph_vit_destroy, &vit); ------------------ | | 695| 61.2k| do { \ | | 696| 61.2k| /* the following branch makes the compiler check the compatibility of \ | | 697| 61.2k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 61.2k| * incorrect destructor function with the pointer */ \ | | 699| 61.2k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 61.2k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 61.2k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 1221| | 1222| 61.2k| if (mode != IGRAPH_OUT && mode != IGRAPH_IN && mode != IGRAPH_ALL) { ------------------ | Branch (1222:9): [True: 54.9k, False: 6.29k] | Branch (1222:31): [True: 2.06k, False: 52.8k] | Branch (1222:52): [True: 0, False: 2.06k] ------------------ 1223| 0| IGRAPH_ERROR("Invalid mode for degree calculation.", IGRAPH_EINVMODE); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1224| 0| } 1225| | 1226| 61.2k| nodes_to_calc = IGRAPH_VIT_SIZE(vit); ------------------ | | 194| 61.2k|#define IGRAPH_VIT_SIZE(vit) ((vit).end - (vit).start) ------------------ 1227| 61.2k| if (!igraph_is_directed(graph)) { ------------------ | Branch (1227:9): [True: 2.99k, False: 58.2k] ------------------ 1228| 2.99k| mode = IGRAPH_ALL; 1229| 2.99k| } 1230| | 1231| 61.2k| IGRAPH_CHECK(igraph_vector_int_resize(res, nodes_to_calc)); ------------------ | | 752| 61.2k| do { \ | | 753| 61.2k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 61.2k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 61.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 61.2k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 61.2k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1232| 61.2k| igraph_vector_int_null(res); 1233| | 1234| 61.2k| if (loops) { ------------------ | Branch (1234:9): [True: 60.5k, False: 709] ------------------ 1235| 60.5k| if (mode & IGRAPH_OUT) { ------------------ | Branch (1235:13): [True: 7.65k, False: 52.8k] ------------------ 1236| 7.65k| for (IGRAPH_VIT_RESET(vit), i = 0; ------------------ | | 205| 7.65k|#define IGRAPH_VIT_RESET(vit) ((vit).pos = (vit).start) ------------------ 1237| 156k| !IGRAPH_VIT_END(vit); ------------------ | | 183| 156k|#define IGRAPH_VIT_END(vit) ((vit).pos >= (vit).end) ------------------ | Branch (1237:18): [True: 148k, False: 7.65k] ------------------ 1238| 148k| IGRAPH_VIT_NEXT(vit), i++) { ------------------ | | 171| 148k|#define IGRAPH_VIT_NEXT(vit) (++((vit).pos)) ------------------ 1239| 148k| igraph_integer_t vid = IGRAPH_VIT_GET(vit); ------------------ | | 218| 148k| ((igraph_integer_t)(((vit).type == IGRAPH_VIT_RANGE) ? (vit).pos : \ | | ------------------ | | | Branch (218:25): [True: 148k, False: 0] | | ------------------ | | 219| 148k| VECTOR(*(vit).vec)[(vit).pos])) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1240| 148k| VECTOR(*res)[i] += (VECTOR(graph->os)[vid + 1] - VECTOR(graph->os)[vid]); ------------------ | | 69| 148k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*res)[i] += (VECTOR(graph->os)[vid + 1] - VECTOR(graph->os)[vid]); ------------------ | | 69| 148k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*res)[i] += (VECTOR(graph->os)[vid + 1] - VECTOR(graph->os)[vid]); ------------------ | | 69| 148k|#define VECTOR(v) ((v).stor_begin) ------------------ 1241| 148k| } 1242| 7.65k| } 1243| 60.5k| if (mode & IGRAPH_IN) { ------------------ | Branch (1243:13): [True: 55.1k, False: 5.36k] ------------------ 1244| 55.1k| for (IGRAPH_VIT_RESET(vit), i = 0; ------------------ | | 205| 55.1k|#define IGRAPH_VIT_RESET(vit) ((vit).pos = (vit).start) ------------------ 1245| 706k| !IGRAPH_VIT_END(vit); ------------------ | | 183| 706k|#define IGRAPH_VIT_END(vit) ((vit).pos >= (vit).end) ------------------ | Branch (1245:18): [True: 651k, False: 55.1k] ------------------ 1246| 651k| IGRAPH_VIT_NEXT(vit), i++) { ------------------ | | 171| 651k|#define IGRAPH_VIT_NEXT(vit) (++((vit).pos)) ------------------ 1247| 651k| igraph_integer_t vid = IGRAPH_VIT_GET(vit); ------------------ | | 218| 651k| ((igraph_integer_t)(((vit).type == IGRAPH_VIT_RANGE) ? (vit).pos : \ | | ------------------ | | | Branch (218:25): [True: 651k, False: 0] | | ------------------ | | 219| 651k| VECTOR(*(vit).vec)[(vit).pos])) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1248| 651k| VECTOR(*res)[i] += (VECTOR(graph->is)[vid + 1] - VECTOR(graph->is)[vid]); ------------------ | | 69| 651k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*res)[i] += (VECTOR(graph->is)[vid + 1] - VECTOR(graph->is)[vid]); ------------------ | | 69| 651k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*res)[i] += (VECTOR(graph->is)[vid + 1] - VECTOR(graph->is)[vid]); ------------------ | | 69| 651k|#define VECTOR(v) ((v).stor_begin) ------------------ 1249| 651k| } 1250| 55.1k| } 1251| 60.5k| } else { /* no loops */ 1252| 709| if (mode & IGRAPH_OUT) { ------------------ | Branch (1252:13): [True: 709, False: 0] ------------------ 1253| 709| for (IGRAPH_VIT_RESET(vit), i = 0; ------------------ | | 205| 709|#define IGRAPH_VIT_RESET(vit) ((vit).pos = (vit).start) ------------------ 1254| 7.90k| !IGRAPH_VIT_END(vit); ------------------ | | 183| 7.90k|#define IGRAPH_VIT_END(vit) ((vit).pos >= (vit).end) ------------------ | Branch (1254:18): [True: 7.19k, False: 709] ------------------ 1255| 7.19k| IGRAPH_VIT_NEXT(vit), i++) { ------------------ | | 171| 7.19k|#define IGRAPH_VIT_NEXT(vit) (++((vit).pos)) ------------------ 1256| 7.19k| igraph_integer_t vid = IGRAPH_VIT_GET(vit); ------------------ | | 218| 7.19k| ((igraph_integer_t)(((vit).type == IGRAPH_VIT_RANGE) ? (vit).pos : \ | | ------------------ | | | Branch (218:25): [True: 7.19k, False: 0] | | ------------------ | | 219| 7.19k| VECTOR(*(vit).vec)[(vit).pos])) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1257| 7.19k| VECTOR(*res)[i] += (VECTOR(graph->os)[vid + 1] - VECTOR(graph->os)[vid]); ------------------ | | 69| 7.19k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*res)[i] += (VECTOR(graph->os)[vid + 1] - VECTOR(graph->os)[vid]); ------------------ | | 69| 7.19k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*res)[i] += (VECTOR(graph->os)[vid + 1] - VECTOR(graph->os)[vid]); ------------------ | | 69| 7.19k|#define VECTOR(v) ((v).stor_begin) ------------------ 1258| 7.19k| for (j = VECTOR(graph->os)[vid]; ------------------ | | 69| 7.19k|#define VECTOR(v) ((v).stor_begin) ------------------ 1259| 18.2k| j < VECTOR(graph->os)[vid + 1]; j++) { ------------------ | | 69| 18.2k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1259:22): [True: 11.0k, False: 7.19k] ------------------ 1260| 11.0k| if (VECTOR(graph->to)[ VECTOR(graph->oi)[j] ] == vid) { ------------------ | | 69| 11.0k|#define VECTOR(v) ((v).stor_begin) ------------------ if (VECTOR(graph->to)[ VECTOR(graph->oi)[j] ] == vid) { ------------------ | | 69| 11.0k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1260:25): [True: 0, False: 11.0k] ------------------ 1261| 0| VECTOR(*res)[i] -= 1; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 1262| 0| } 1263| 11.0k| } 1264| 7.19k| } 1265| 709| } 1266| 709| if (mode & IGRAPH_IN) { ------------------ | Branch (1266:13): [True: 709, False: 0] ------------------ 1267| 709| for (IGRAPH_VIT_RESET(vit), i = 0; ------------------ | | 205| 709|#define IGRAPH_VIT_RESET(vit) ((vit).pos = (vit).start) ------------------ 1268| 7.90k| !IGRAPH_VIT_END(vit); ------------------ | | 183| 7.90k|#define IGRAPH_VIT_END(vit) ((vit).pos >= (vit).end) ------------------ | Branch (1268:18): [True: 7.19k, False: 709] ------------------ 1269| 7.19k| IGRAPH_VIT_NEXT(vit), i++) { ------------------ | | 171| 7.19k|#define IGRAPH_VIT_NEXT(vit) (++((vit).pos)) ------------------ 1270| 7.19k| igraph_integer_t vid = IGRAPH_VIT_GET(vit); ------------------ | | 218| 7.19k| ((igraph_integer_t)(((vit).type == IGRAPH_VIT_RANGE) ? (vit).pos : \ | | ------------------ | | | Branch (218:25): [True: 7.19k, False: 0] | | ------------------ | | 219| 7.19k| VECTOR(*(vit).vec)[(vit).pos])) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1271| 7.19k| VECTOR(*res)[i] += (VECTOR(graph->is)[vid + 1] - VECTOR(graph->is)[vid]); ------------------ | | 69| 7.19k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*res)[i] += (VECTOR(graph->is)[vid + 1] - VECTOR(graph->is)[vid]); ------------------ | | 69| 7.19k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(*res)[i] += (VECTOR(graph->is)[vid + 1] - VECTOR(graph->is)[vid]); ------------------ | | 69| 7.19k|#define VECTOR(v) ((v).stor_begin) ------------------ 1272| 7.19k| for (j = VECTOR(graph->is)[vid]; ------------------ | | 69| 7.19k|#define VECTOR(v) ((v).stor_begin) ------------------ 1273| 18.2k| j < VECTOR(graph->is)[vid + 1]; j++) { ------------------ | | 69| 18.2k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1273:22): [True: 11.0k, False: 7.19k] ------------------ 1274| 11.0k| if (VECTOR(graph->from)[ VECTOR(graph->ii)[j] ] == vid) { ------------------ | | 69| 11.0k|#define VECTOR(v) ((v).stor_begin) ------------------ if (VECTOR(graph->from)[ VECTOR(graph->ii)[j] ] == vid) { ------------------ | | 69| 11.0k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1274:25): [True: 0, False: 11.0k] ------------------ 1275| 0| VECTOR(*res)[i] -= 1; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 1276| 0| } 1277| 11.0k| } 1278| 7.19k| } 1279| 709| } 1280| 709| } /* loops */ 1281| | 1282| 61.2k| igraph_vit_destroy(&vit); 1283| 61.2k| IGRAPH_FINALLY_CLEAN(1); 1284| | 1285| 61.2k| return IGRAPH_SUCCESS; 1286| 61.2k|} igraph_get_eid: 1384| 58.4k| igraph_bool_t directed, igraph_bool_t error) { 1385| | 1386| 58.4k| igraph_integer_t no_of_nodes = igraph_vcount(graph); 1387| | 1388| 58.4k| if (from < 0 || to < 0 || from >= no_of_nodes || to >= no_of_nodes) { ------------------ | Branch (1388:9): [True: 0, False: 58.4k] | Branch (1388:21): [True: 0, False: 58.4k] | Branch (1388:31): [True: 0, False: 58.4k] | Branch (1388:54): [True: 0, False: 58.4k] ------------------ 1389| 0| IGRAPH_ERROR("Cannot get edge ID.", IGRAPH_EINVVID); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1390| 0| } 1391| | 1392| 58.4k| *eid = -1; 1393| 58.4k| if (igraph_is_directed(graph)) { ------------------ | Branch (1393:9): [True: 41.4k, False: 17.0k] ------------------ 1394| | 1395| | /* Directed graph */ 1396| 41.4k| FIND_DIRECTED_EDGE(graph, from, to, eid); ------------------ | | 1330| 41.4k| do { \ | | 1331| 41.4k| igraph_integer_t start = VECTOR(graph->os)[xfrom]; \ | | ------------------ | | | | 69| 41.4k|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | 1332| 41.4k| igraph_integer_t end = VECTOR(graph->os)[xfrom+1]; \ | | ------------------ | | | | 69| 41.4k|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | 1333| 41.4k| igraph_integer_t N = end; \ | | 1334| 41.4k| igraph_integer_t start2 = VECTOR(graph->is)[xto]; \ | | ------------------ | | | | 69| 41.4k|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | 1335| 41.4k| igraph_integer_t end2 = VECTOR(graph->is)[xto+1]; \ | | ------------------ | | | | 69| 41.4k|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | 1336| 41.4k| igraph_integer_t N2 = end2; \ | | 1337| 41.4k| igraph_integer_t *nullpointer = NULL; \ | | 1338| 41.4k| if (end-start < end2-start2) { \ | | ------------------ | | | Branch (1338:13): [True: 7.49k, False: 33.9k] | | ------------------ | | 1339| 7.49k| BINSEARCH(start, end, xto, graph->oi, graph->to, N, eid, nullpointer); \ | | ------------------ | | | | 1310| 7.49k| do { \ | | | | 1311| 23.2k| while ((start) < (end)) { \ | | | | ------------------ | | | | | Branch (1311:16): [True: 15.7k, False: 7.49k] | | | | ------------------ | | | | 1312| 15.7k| igraph_integer_t mid =(start)+((end)-(start))/2; \ | | | | 1313| 15.7k| igraph_integer_t e = VECTOR((iindex))[mid]; \ | | | | ------------------ | | | | | | 69| 15.7k|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | | | 1314| 15.7k| if (VECTOR((edgelist))[e] < (value)) { \ | | | | ------------------ | | | | | | 69| 15.7k|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | | | | Branch (1314:17): [True: 8.30k, False: 7.47k] | | | | ------------------ | | | | 1315| 8.30k| (start) = mid+1; \ | | | | 1316| 8.30k| } else { \ | | | | 1317| 7.47k| (end) = mid; \ | | | | 1318| 7.47k| } \ | | | | 1319| 15.7k| } \ | | | | 1320| 7.49k| if ((start) < (N)) { \ | | | | ------------------ | | | | | Branch (1320:13): [True: 5.20k, False: 2.29k] | | | | ------------------ | | | | 1321| 5.20k| igraph_integer_t e = VECTOR((iindex))[(start)]; \ | | | | ------------------ | | | | | | 69| 5.20k|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | | | 1322| 5.20k| if (VECTOR((edgelist))[e] == (value)) { \ | | | | ------------------ | | | | | | 69| 5.20k|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | | | | Branch (1322:17): [True: 2.70k, False: 2.49k] | | | | ------------------ | | | | 1323| 2.70k| *(result) = e; \ | | | | 1324| 2.70k| if (result_pos != 0) { *(result_pos) = start; } \ | | | | ------------------ | | | | | Branch (1324:21): [True: 0, False: 2.70k] | | | | ------------------ | | | | 1325| 2.70k| } \ | | | | 1326| 5.20k| } \ | | | | 1327| 7.49k| } while (0) | | | | ------------------ | | | | | Branch (1327:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 1340| 33.9k| } else { \ | | 1341| 33.9k| BINSEARCH(start2, end2, xfrom, graph->ii, graph->from, N2, eid, nullpointer); \ | | ------------------ | | | | 1310| 33.9k| do { \ | | | | 1311| 106k| while ((start) < (end)) { \ | | | | ------------------ | | | | | Branch (1311:16): [True: 72.8k, False: 33.9k] | | | | ------------------ | | | | 1312| 72.8k| igraph_integer_t mid =(start)+((end)-(start))/2; \ | | | | 1313| 72.8k| igraph_integer_t e = VECTOR((iindex))[mid]; \ | | | | ------------------ | | | | | | 69| 72.8k|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | | | 1314| 72.8k| if (VECTOR((edgelist))[e] < (value)) { \ | | | | ------------------ | | | | | | 69| 72.8k|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | | | | Branch (1314:17): [True: 19.1k, False: 53.7k] | | | | ------------------ | | | | 1315| 19.1k| (start) = mid+1; \ | | | | 1316| 53.7k| } else { \ | | | | 1317| 53.7k| (end) = mid; \ | | | | 1318| 53.7k| } \ | | | | 1319| 72.8k| } \ | | | | 1320| 33.9k| if ((start) < (N)) { \ | | | | ------------------ | | | | | Branch (1320:13): [True: 30.0k, False: 3.91k] | | | | ------------------ | | | | 1321| 30.0k| igraph_integer_t e = VECTOR((iindex))[(start)]; \ | | | | ------------------ | | | | | | 69| 30.0k|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | | | 1322| 30.0k| if (VECTOR((edgelist))[e] == (value)) { \ | | | | ------------------ | | | | | | 69| 30.0k|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | | | | Branch (1322:17): [True: 9.27k, False: 20.7k] | | | | ------------------ | | | | 1323| 9.27k| *(result) = e; \ | | | | 1324| 9.27k| if (result_pos != 0) { *(result_pos) = start; } \ | | | | ------------------ | | | | | Branch (1324:21): [True: 0, False: 9.27k] | | | | ------------------ | | | | 1325| 9.27k| } \ | | | | 1326| 30.0k| } \ | | | | 1327| 33.9k| } while (0) | | | | ------------------ | | | | | Branch (1327:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 1342| 33.9k| } \ | | 1343| 41.4k| } while (0) | | ------------------ | | | Branch (1343:14): [Folded - Ignored] | | ------------------ ------------------ 1397| 41.4k| if (!directed && *eid < 0) { ------------------ | Branch (1397:13): [True: 0, False: 41.4k] | Branch (1397:26): [True: 0, False: 0] ------------------ 1398| 0| FIND_DIRECTED_EDGE(graph, to, from, eid); ------------------ | | 1330| 0| do { \ | | 1331| 0| igraph_integer_t start = VECTOR(graph->os)[xfrom]; \ | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | 1332| 0| igraph_integer_t end = VECTOR(graph->os)[xfrom+1]; \ | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | 1333| 0| igraph_integer_t N = end; \ | | 1334| 0| igraph_integer_t start2 = VECTOR(graph->is)[xto]; \ | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | 1335| 0| igraph_integer_t end2 = VECTOR(graph->is)[xto+1]; \ | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | 1336| 0| igraph_integer_t N2 = end2; \ | | 1337| 0| igraph_integer_t *nullpointer = NULL; \ | | 1338| 0| if (end-start < end2-start2) { \ | | ------------------ | | | Branch (1338:13): [True: 0, False: 0] | | ------------------ | | 1339| 0| BINSEARCH(start, end, xto, graph->oi, graph->to, N, eid, nullpointer); \ | | ------------------ | | | | 1310| 0| do { \ | | | | 1311| 0| while ((start) < (end)) { \ | | | | ------------------ | | | | | Branch (1311:16): [True: 0, False: 0] | | | | ------------------ | | | | 1312| 0| igraph_integer_t mid =(start)+((end)-(start))/2; \ | | | | 1313| 0| igraph_integer_t e = VECTOR((iindex))[mid]; \ | | | | ------------------ | | | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | | | 1314| 0| if (VECTOR((edgelist))[e] < (value)) { \ | | | | ------------------ | | | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | | | | Branch (1314:17): [True: 0, False: 0] | | | | ------------------ | | | | 1315| 0| (start) = mid+1; \ | | | | 1316| 0| } else { \ | | | | 1317| 0| (end) = mid; \ | | | | 1318| 0| } \ | | | | 1319| 0| } \ | | | | 1320| 0| if ((start) < (N)) { \ | | | | ------------------ | | | | | Branch (1320:13): [True: 0, False: 0] | | | | ------------------ | | | | 1321| 0| igraph_integer_t e = VECTOR((iindex))[(start)]; \ | | | | ------------------ | | | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | | | 1322| 0| if (VECTOR((edgelist))[e] == (value)) { \ | | | | ------------------ | | | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | | | | Branch (1322:17): [True: 0, False: 0] | | | | ------------------ | | | | 1323| 0| *(result) = e; \ | | | | 1324| 0| if (result_pos != 0) { *(result_pos) = start; } \ | | | | ------------------ | | | | | Branch (1324:21): [True: 0, False: 0] | | | | ------------------ | | | | 1325| 0| } \ | | | | 1326| 0| } \ | | | | 1327| 0| } while (0) | | | | ------------------ | | | | | Branch (1327:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 1340| 0| } else { \ | | 1341| 0| BINSEARCH(start2, end2, xfrom, graph->ii, graph->from, N2, eid, nullpointer); \ | | ------------------ | | | | 1310| 0| do { \ | | | | 1311| 0| while ((start) < (end)) { \ | | | | ------------------ | | | | | Branch (1311:16): [True: 0, False: 0] | | | | ------------------ | | | | 1312| 0| igraph_integer_t mid =(start)+((end)-(start))/2; \ | | | | 1313| 0| igraph_integer_t e = VECTOR((iindex))[mid]; \ | | | | ------------------ | | | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | | | 1314| 0| if (VECTOR((edgelist))[e] < (value)) { \ | | | | ------------------ | | | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | | | | Branch (1314:17): [True: 0, False: 0] | | | | ------------------ | | | | 1315| 0| (start) = mid+1; \ | | | | 1316| 0| } else { \ | | | | 1317| 0| (end) = mid; \ | | | | 1318| 0| } \ | | | | 1319| 0| } \ | | | | 1320| 0| if ((start) < (N)) { \ | | | | ------------------ | | | | | Branch (1320:13): [True: 0, False: 0] | | | | ------------------ | | | | 1321| 0| igraph_integer_t e = VECTOR((iindex))[(start)]; \ | | | | ------------------ | | | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | | | 1322| 0| if (VECTOR((edgelist))[e] == (value)) { \ | | | | ------------------ | | | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | | | | Branch (1322:17): [True: 0, False: 0] | | | | ------------------ | | | | 1323| 0| *(result) = e; \ | | | | 1324| 0| if (result_pos != 0) { *(result_pos) = start; } \ | | | | ------------------ | | | | | Branch (1324:21): [True: 0, False: 0] | | | | ------------------ | | | | 1325| 0| } \ | | | | 1326| 0| } \ | | | | 1327| 0| } while (0) | | | | ------------------ | | | | | Branch (1327:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 1342| 0| } \ | | 1343| 0| } while (0) | | ------------------ | | | Branch (1343:14): [Folded - Ignored] | | ------------------ ------------------ 1399| 0| } 1400| | 1401| 41.4k| } else { 1402| | 1403| | /* Undirected graph, they only have one mode */ 1404| 17.0k| FIND_UNDIRECTED_EDGE(graph, from, to, eid); ------------------ | | 1346| 17.0k| do { \ | | 1347| 17.0k| igraph_integer_t xfrom1 = from > to ? from : to; \ | | ------------------ | | | Branch (1347:35): [True: 5.25k, False: 11.7k] | | ------------------ | | 1348| 17.0k| igraph_integer_t xto1 = from > to ? to : from; \ | | ------------------ | | | Branch (1348:33): [True: 5.25k, False: 11.7k] | | ------------------ | | 1349| 17.0k| FIND_DIRECTED_EDGE(graph, xfrom1, xto1, eid); \ | | ------------------ | | | | 1330| 17.0k| do { \ | | | | 1331| 17.0k| igraph_integer_t start = VECTOR(graph->os)[xfrom]; \ | | | | ------------------ | | | | | | 69| 17.0k|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | | | 1332| 17.0k| igraph_integer_t end = VECTOR(graph->os)[xfrom+1]; \ | | | | ------------------ | | | | | | 69| 17.0k|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | | | 1333| 17.0k| igraph_integer_t N = end; \ | | | | 1334| 17.0k| igraph_integer_t start2 = VECTOR(graph->is)[xto]; \ | | | | ------------------ | | | | | | 69| 17.0k|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | | | 1335| 17.0k| igraph_integer_t end2 = VECTOR(graph->is)[xto+1]; \ | | | | ------------------ | | | | | | 69| 17.0k|#define VECTOR(v) ((v).stor_begin) | | | | ------------------ | | | | 1336| 17.0k| igraph_integer_t N2 = end2; \ | | | | 1337| 17.0k| igraph_integer_t *nullpointer = NULL; \ | | | | 1338| 17.0k| if (end-start < end2-start2) { \ | | | | ------------------ | | | | | Branch (1338:13): [True: 11.4k, False: 5.59k] | | | | ------------------ | | | | 1339| 11.4k| BINSEARCH(start, end, xto, graph->oi, graph->to, N, eid, nullpointer); \ | | | | ------------------ | | | | | | 1310| 11.4k| do { \ | | | | | | 1311| 31.6k| while ((start) < (end)) { \ | | | | | | ------------------ | | | | | | | Branch (1311:16): [True: 20.2k, False: 11.4k] | | | | | | ------------------ | | | | | | 1312| 20.2k| igraph_integer_t mid =(start)+((end)-(start))/2; \ | | | | | | 1313| 20.2k| igraph_integer_t e = VECTOR((iindex))[mid]; \ | | | | | | ------------------ | | | | | | | | 69| 20.2k|#define VECTOR(v) ((v).stor_begin) | | | | | | ------------------ | | | | | | 1314| 20.2k| if (VECTOR((edgelist))[e] < (value)) { \ | | | | | | ------------------ | | | | | | | | 69| 20.2k|#define VECTOR(v) ((v).stor_begin) | | | | | | ------------------ | | | | | | | Branch (1314:17): [True: 5.84k, False: 14.4k] | | | | | | ------------------ | | | | | | 1315| 5.84k| (start) = mid+1; \ | | | | | | 1316| 14.4k| } else { \ | | | | | | 1317| 14.4k| (end) = mid; \ | | | | | | 1318| 14.4k| } \ | | | | | | 1319| 20.2k| } \ | | | | | | 1320| 11.4k| if ((start) < (N)) { \ | | | | | | ------------------ | | | | | | | Branch (1320:13): [True: 9.53k, False: 1.87k] | | | | | | ------------------ | | | | | | 1321| 9.53k| igraph_integer_t e = VECTOR((iindex))[(start)]; \ | | | | | | ------------------ | | | | | | | | 69| 9.53k|#define VECTOR(v) ((v).stor_begin) | | | | | | ------------------ | | | | | | 1322| 9.53k| if (VECTOR((edgelist))[e] == (value)) { \ | | | | | | ------------------ | | | | | | | | 69| 9.53k|#define VECTOR(v) ((v).stor_begin) | | | | | | ------------------ | | | | | | | Branch (1322:17): [True: 4.96k, False: 4.56k] | | | | | | ------------------ | | | | | | 1323| 4.96k| *(result) = e; \ | | | | | | 1324| 4.96k| if (result_pos != 0) { *(result_pos) = start; } \ | | | | | | ------------------ | | | | | | | Branch (1324:21): [True: 0, False: 4.96k] | | | | | | ------------------ | | | | | | 1325| 4.96k| } \ | | | | | | 1326| 9.53k| } \ | | | | | | 1327| 11.4k| } while (0) | | | | | | ------------------ | | | | | | | Branch (1327:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 1340| 11.4k| } else { \ | | | | 1341| 5.59k| BINSEARCH(start2, end2, xfrom, graph->ii, graph->from, N2, eid, nullpointer); \ | | | | ------------------ | | | | | | 1310| 5.59k| do { \ | | | | | | 1311| 16.6k| while ((start) < (end)) { \ | | | | | | ------------------ | | | | | | | Branch (1311:16): [True: 11.0k, False: 5.59k] | | | | | | ------------------ | | | | | | 1312| 11.0k| igraph_integer_t mid =(start)+((end)-(start))/2; \ | | | | | | 1313| 11.0k| igraph_integer_t e = VECTOR((iindex))[mid]; \ | | | | | | ------------------ | | | | | | | | 69| 11.0k|#define VECTOR(v) ((v).stor_begin) | | | | | | ------------------ | | | | | | 1314| 11.0k| if (VECTOR((edgelist))[e] < (value)) { \ | | | | | | ------------------ | | | | | | | | 69| 11.0k|#define VECTOR(v) ((v).stor_begin) | | | | | | ------------------ | | | | | | | Branch (1314:17): [True: 4.85k, False: 6.20k] | | | | | | ------------------ | | | | | | 1315| 4.85k| (start) = mid+1; \ | | | | | | 1316| 6.20k| } else { \ | | | | | | 1317| 6.20k| (end) = mid; \ | | | | | | 1318| 6.20k| } \ | | | | | | 1319| 11.0k| } \ | | | | | | 1320| 5.59k| if ((start) < (N)) { \ | | | | | | ------------------ | | | | | | | Branch (1320:13): [True: 4.44k, False: 1.15k] | | | | | | ------------------ | | | | | | 1321| 4.44k| igraph_integer_t e = VECTOR((iindex))[(start)]; \ | | | | | | ------------------ | | | | | | | | 69| 4.44k|#define VECTOR(v) ((v).stor_begin) | | | | | | ------------------ | | | | | | 1322| 4.44k| if (VECTOR((edgelist))[e] == (value)) { \ | | | | | | ------------------ | | | | | | | | 69| 4.44k|#define VECTOR(v) ((v).stor_begin) | | | | | | ------------------ | | | | | | | Branch (1322:17): [True: 3.01k, False: 1.43k] | | | | | | ------------------ | | | | | | 1323| 3.01k| *(result) = e; \ | | | | | | 1324| 3.01k| if (result_pos != 0) { *(result_pos) = start; } \ | | | | | | ------------------ | | | | | | | Branch (1324:21): [True: 0, False: 3.01k] | | | | | | ------------------ | | | | | | 1325| 3.01k| } \ | | | | | | 1326| 4.44k| } \ | | | | | | 1327| 5.59k| } while (0) | | | | | | ------------------ | | | | | | | Branch (1327:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 1342| 5.59k| } \ | | | | 1343| 17.0k| } while (0) | | | | ------------------ | | | | | Branch (1343:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 1350| 17.0k| } while (0) | | ------------------ | | | Branch (1350:14): [Folded - Ignored] | | ------------------ ------------------ 1405| | 1406| 17.0k| } 1407| | 1408| 58.4k| if (*eid < 0) { ------------------ | Branch (1408:9): [True: 38.4k, False: 19.9k] ------------------ 1409| 38.4k| if (error) { ------------------ | Branch (1409:13): [True: 0, False: 38.4k] ------------------ 1410| 0| IGRAPH_ERROR("Cannot get edge ID, no such edge", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1411| 0| } 1412| 38.4k| } 1413| | 1414| 58.4k| return IGRAPH_SUCCESS; 1415| 58.4k|} igraph_incident: 1630| 174k| igraph_neimode_t mode) { 1631| 174k| if (!igraph_is_directed(graph) || mode == IGRAPH_ALL) { ------------------ | Branch (1631:9): [True: 8.43k, False: 165k] | Branch (1631:39): [True: 117k, False: 48.1k] ------------------ 1632| 126k| return igraph_i_incident(graph, eids, pnode, mode, IGRAPH_LOOPS_TWICE); 1633| 126k| } else { 1634| 48.1k| return igraph_i_incident(graph, eids, pnode, mode, IGRAPH_LOOPS_ONCE); 1635| 48.1k| } 1636| 174k|} igraph_i_incident: 1639| 174k| igraph_neimode_t mode, igraph_loops_t loops) { 1640| 174k| igraph_integer_t length = 0, idx = 0; 1641| 174k| igraph_integer_t i, j; 1642| 174k| igraph_integer_t node = pnode; 1643| 174k| igraph_bool_t directed = igraph_is_directed(graph); 1644| | 1645| 174k| if (node < 0 || node > igraph_vcount(graph) - 1) { ------------------ | Branch (1645:9): [True: 0, False: 174k] | Branch (1645:21): [True: 0, False: 174k] ------------------ 1646| 0| IGRAPH_ERROR("Given vertex is not in the graph.", IGRAPH_EINVVID); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1647| 0| } 1648| 174k| if (mode != IGRAPH_OUT && mode != IGRAPH_IN && ------------------ | Branch (1648:9): [True: 126k, False: 48.1k] | Branch (1648:31): [True: 126k, False: 0] ------------------ 1649| 174k| mode != IGRAPH_ALL) { ------------------ | Branch (1649:9): [True: 0, False: 126k] ------------------ 1650| 0| IGRAPH_ERROR("Mode should be either IGRAPH_OUT, IGRAPH_IN or IGRAPH_ALL.", IGRAPH_EINVMODE); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1651| 0| } 1652| | 1653| 174k| if (!directed) { ------------------ | Branch (1653:9): [True: 8.43k, False: 165k] ------------------ 1654| 8.43k| mode = IGRAPH_ALL; 1655| 8.43k| } 1656| | 1657| 174k| if (mode != IGRAPH_ALL && loops == IGRAPH_LOOPS_TWICE) { ------------------ | Branch (1657:9): [True: 48.1k, False: 126k] | Branch (1657:31): [True: 0, False: 48.1k] ------------------ 1658| 0| IGRAPH_ERROR("For a directed graph (with directions not ignored), " ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 1659| 0| "IGRAPH_LOOPS_TWICE does not make sense.\n", IGRAPH_EINVAL); 1660| 0| } 1661| | 1662| | /* Calculate needed space first & allocate it */ 1663| | /* Note that 'mode' is treated as a bit field here; it's okay because 1664| | * IGRAPH_ALL = IGRAPH_IN | IGRAPH_OUT, bit-wise */ 1665| 174k| if (mode & IGRAPH_OUT) { ------------------ | Branch (1665:9): [True: 174k, False: 0] ------------------ 1666| 174k| length += (VECTOR(graph->os)[node + 1] - VECTOR(graph->os)[node]); ------------------ | | 69| 174k|#define VECTOR(v) ((v).stor_begin) ------------------ length += (VECTOR(graph->os)[node + 1] - VECTOR(graph->os)[node]); ------------------ | | 69| 174k|#define VECTOR(v) ((v).stor_begin) ------------------ 1667| 174k| } 1668| 174k| if (mode & IGRAPH_IN) { ------------------ | Branch (1668:9): [True: 126k, False: 48.1k] ------------------ 1669| 126k| length += (VECTOR(graph->is)[node + 1] - VECTOR(graph->is)[node]); ------------------ | | 69| 126k|#define VECTOR(v) ((v).stor_begin) ------------------ length += (VECTOR(graph->is)[node + 1] - VECTOR(graph->is)[node]); ------------------ | | 69| 126k|#define VECTOR(v) ((v).stor_begin) ------------------ 1670| 126k| } 1671| | 1672| 174k| IGRAPH_CHECK(igraph_vector_int_resize(eids, length)); ------------------ | | 752| 174k| do { \ | | 753| 174k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 174k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 174k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 174k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 174k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1673| | 1674| | /* The loops below produce an ordering what is consistent with the 1675| | * ordering returned by igraph_neighbors(), and this should be preserved. 1676| | * We are dealing with two sorted lists; one for the successors and one 1677| | * for the predecessors. If we have requested only one of them, we have 1678| | * an easy job. If we have requested both, we need to merge the two lists 1679| | * to ensure that the output is sorted by the vertex IDs of the "other" 1680| | * endpoint of the affected edges */ 1681| 174k| if (!directed || mode != IGRAPH_ALL) { ------------------ | Branch (1681:9): [True: 8.43k, False: 165k] | Branch (1681:22): [True: 48.1k, False: 117k] ------------------ 1682| | /* We did not ask for both directions; this is the easy case */ 1683| | 1684| 56.6k| if (mode & IGRAPH_OUT) { ------------------ | Branch (1684:13): [True: 56.6k, False: 0] ------------------ 1685| 56.6k| j = VECTOR(graph->os)[node + 1]; ------------------ | | 69| 56.6k|#define VECTOR(v) ((v).stor_begin) ------------------ 1686| 471k| for (i = VECTOR(graph->os)[node]; i < j; i++) { ------------------ | | 69| 56.6k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1686:47): [True: 414k, False: 56.6k] ------------------ 1687| 414k| igraph_integer_t edge = VECTOR(graph->oi)[i]; ------------------ | | 69| 414k|#define VECTOR(v) ((v).stor_begin) ------------------ 1688| 414k| igraph_integer_t other = VECTOR(graph->to)[edge]; ------------------ | | 69| 414k|#define VECTOR(v) ((v).stor_begin) ------------------ 1689| 414k| if (loops == IGRAPH_NO_LOOPS && other == pnode) { ------------------ | Branch (1689:21): [True: 0, False: 414k] | Branch (1689:49): [True: 0, False: 0] ------------------ 1690| 0| length--; 1691| 414k| } else { 1692| 414k| VECTOR(*eids)[idx++] = edge; ------------------ | | 69| 414k|#define VECTOR(v) ((v).stor_begin) ------------------ 1693| 414k| } 1694| 414k| } 1695| 56.6k| } 1696| | 1697| 56.6k| if (mode & IGRAPH_IN) { ------------------ | Branch (1697:13): [True: 8.43k, False: 48.1k] ------------------ 1698| 8.43k| j = VECTOR(graph->is)[node + 1]; ------------------ | | 69| 8.43k|#define VECTOR(v) ((v).stor_begin) ------------------ 1699| 27.6k| for (i = VECTOR(graph->is)[node]; i < j; i++) { ------------------ | | 69| 8.43k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (1699:47): [True: 19.2k, False: 8.43k] ------------------ 1700| 19.2k| igraph_integer_t edge = VECTOR(graph->ii)[i]; ------------------ | | 69| 19.2k|#define VECTOR(v) ((v).stor_begin) ------------------ 1701| 19.2k| igraph_integer_t other = VECTOR(graph->from)[edge]; ------------------ | | 69| 19.2k|#define VECTOR(v) ((v).stor_begin) ------------------ 1702| 19.2k| if ((loops == IGRAPH_NO_LOOPS || (loops == IGRAPH_LOOPS_ONCE && !directed)) && other == pnode) { ------------------ | Branch (1702:22): [True: 0, False: 19.2k] | Branch (1702:51): [True: 0, False: 19.2k] | Branch (1702:81): [True: 0, False: 0] | Branch (1702:96): [True: 0, False: 0] ------------------ 1703| 0| length--; 1704| 19.2k| } else { 1705| 19.2k| VECTOR(*eids)[idx++] = edge; ------------------ | | 69| 19.2k|#define VECTOR(v) ((v).stor_begin) ------------------ 1706| 19.2k| } 1707| 19.2k| } 1708| 8.43k| } 1709| 117k| } else { 1710| | /* both in- and out- neighbors in a directed graph, 1711| | we need to merge the two 'vectors' */ 1712| 117k| igraph_integer_t j1 = VECTOR(graph->os)[node + 1]; ------------------ | | 69| 117k|#define VECTOR(v) ((v).stor_begin) ------------------ 1713| 117k| igraph_integer_t j2 = VECTOR(graph->is)[node + 1]; ------------------ | | 69| 117k|#define VECTOR(v) ((v).stor_begin) ------------------ 1714| 117k| igraph_integer_t i1 = VECTOR(graph->os)[node]; ------------------ | | 69| 117k|#define VECTOR(v) ((v).stor_begin) ------------------ 1715| 117k| igraph_integer_t i2 = VECTOR(graph->is)[node]; ------------------ | | 69| 117k|#define VECTOR(v) ((v).stor_begin) ------------------ 1716| 117k| igraph_integer_t eid1, eid2; 1717| 117k| igraph_integer_t n1, n2; 1718| 117k| igraph_bool_t seen_loop_edge = 0; 1719| | 1720| 406k| while (i1 < j1 && i2 < j2) { ------------------ | Branch (1720:16): [True: 329k, False: 76.3k] | Branch (1720:27): [True: 288k, False: 41.5k] ------------------ 1721| 288k| eid1 = VECTOR(graph->oi)[i1]; ------------------ | | 69| 288k|#define VECTOR(v) ((v).stor_begin) ------------------ 1722| 288k| eid2 = VECTOR(graph->ii)[i2]; ------------------ | | 69| 288k|#define VECTOR(v) ((v).stor_begin) ------------------ 1723| 288k| n1 = VECTOR(graph->to)[eid1]; ------------------ | | 69| 288k|#define VECTOR(v) ((v).stor_begin) ------------------ 1724| 288k| n2 = VECTOR(graph->from)[eid2]; ------------------ | | 69| 288k|#define VECTOR(v) ((v).stor_begin) ------------------ 1725| 288k| if (n1 < n2) { ------------------ | Branch (1725:17): [True: 177k, False: 110k] ------------------ 1726| 177k| i1++; 1727| 177k| VECTOR(*eids)[idx++] = eid1; ------------------ | | 69| 177k|#define VECTOR(v) ((v).stor_begin) ------------------ 1728| 177k| } else if (n1 > n2) { ------------------ | Branch (1728:24): [True: 108k, False: 2.27k] ------------------ 1729| 108k| i2++; 1730| 108k| VECTOR(*eids)[idx++] = eid2; ------------------ | | 69| 108k|#define VECTOR(v) ((v).stor_begin) ------------------ 1731| 108k| } else if (n1 != pnode) { ------------------ | Branch (1731:24): [True: 2.27k, False: 0] ------------------ 1732| | /* multiple edge */ 1733| 2.27k| i1++; 1734| 2.27k| i2++; 1735| 2.27k| VECTOR(*eids)[idx++] = eid1; ------------------ | | 69| 2.27k|#define VECTOR(v) ((v).stor_begin) ------------------ 1736| 2.27k| VECTOR(*eids)[idx++] = eid2; ------------------ | | 69| 2.27k|#define VECTOR(v) ((v).stor_begin) ------------------ 1737| 2.27k| } else { 1738| | /* loop edge */ 1739| 0| i1++; 1740| 0| i2++; 1741| 0| if (loops == IGRAPH_NO_LOOPS) { ------------------ | Branch (1741:21): [True: 0, False: 0] ------------------ 1742| 0| length -= 2; 1743| 0| } else if (loops == IGRAPH_LOOPS_ONCE) { ------------------ | Branch (1743:28): [True: 0, False: 0] ------------------ 1744| 0| length--; 1745| 0| if (!seen_loop_edge) { ------------------ | Branch (1745:25): [True: 0, False: 0] ------------------ 1746| 0| VECTOR(*eids)[idx++] = eid1; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 1747| 0| } else { 1748| 0| VECTOR(*eids)[idx++] = eid2; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 1749| 0| } 1750| 0| seen_loop_edge = !seen_loop_edge; 1751| 0| } else { 1752| 0| VECTOR(*eids)[idx++] = eid1; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 1753| 0| VECTOR(*eids)[idx++] = eid2; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 1754| 0| } 1755| 0| } 1756| 288k| } 1757| | 1758| 214k| while (i1 < j1) { ------------------ | Branch (1758:16): [True: 96.1k, False: 117k] ------------------ 1759| 96.1k| eid1 = VECTOR(graph->oi)[i1++]; ------------------ | | 69| 96.1k|#define VECTOR(v) ((v).stor_begin) ------------------ 1760| 96.1k| VECTOR(*eids)[idx++] = eid1; ------------------ | | 69| 96.1k|#define VECTOR(v) ((v).stor_begin) ------------------ 1761| 96.1k| } 1762| | 1763| 307k| while (i2 < j2) { ------------------ | Branch (1763:16): [True: 190k, False: 117k] ------------------ 1764| 190k| eid2 = VECTOR(graph->ii)[i2++]; ------------------ | | 69| 190k|#define VECTOR(v) ((v).stor_begin) ------------------ 1765| 190k| VECTOR(*eids)[idx++] = eid2; ------------------ | | 69| 190k|#define VECTOR(v) ((v).stor_begin) ------------------ 1766| 190k| } 1767| 117k| } 1768| 174k| IGRAPH_CHECK(igraph_vector_int_resize(eids, length)); ------------------ | | 752| 174k| do { \ | | 753| 174k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 174k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 174k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 174k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 174k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1769| 174k| return IGRAPH_SUCCESS; 1770| 174k|#undef DEDUPLICATE_IF_NEEDED 1771| 174k|} type_indexededgelist.c:igraph_i_create_start_vectors: 1047| 188k| igraph_vector_int_t *iindex, igraph_integer_t nodes) { 1048| | 1049| 188k|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) 1050| | 1051| 188k| igraph_integer_t no_of_nodes; 1052| 188k| igraph_integer_t no_of_edges; 1053| 188k| igraph_integer_t i, j, idx; 1054| | 1055| 188k| no_of_nodes = nodes; 1056| 188k| no_of_edges = igraph_vector_int_size(el); 1057| | 1058| | /* result */ 1059| | 1060| 188k| IGRAPH_CHECK(igraph_vector_int_resize(res, nodes + 1)); ------------------ | | 752| 188k| do { \ | | 753| 188k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 188k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 188k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 188k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 188k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 1061| | 1062| | /* create the index */ 1063| | 1064| 188k| if (no_of_edges == 0) { ------------------ | Branch (1064:9): [True: 0, False: 188k] ------------------ 1065| | /* empty graph */ 1066| 0| igraph_vector_int_null(res); 1067| 188k| } else { 1068| 188k| idx = -1; 1069| 441k| for (i = 0; i <= EDGE(0); i++) { ------------------ | | 1049| 441k|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 69| 441k|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 69| 441k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (1069:21): [True: 253k, False: 188k] ------------------ 1070| 253k| idx++; VECTOR(*res)[idx] = 0; ------------------ | | 69| 253k|#define VECTOR(v) ((v).stor_begin) ------------------ 1071| 253k| } 1072| 6.25M| for (i = 1; i < no_of_edges; i++) { ------------------ | Branch (1072:21): [True: 6.06M, False: 188k] ------------------ 1073| 6.06M| igraph_integer_t n = EDGE(i) - EDGE(VECTOR(*res)[idx]); ------------------ | | 1049| 6.06M|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 69| 6.06M|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 69| 6.06M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ igraph_integer_t n = EDGE(i) - EDGE(VECTOR(*res)[idx]); ------------------ | | 1049| 6.06M|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 69| 6.06M|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 69| 6.06M|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1074| 8.34M| for (j = 0; j < n; j++) { ------------------ | Branch (1074:25): [True: 2.28M, False: 6.06M] ------------------ 1075| 2.28M| idx++; VECTOR(*res)[idx] = i; ------------------ | | 69| 2.28M|#define VECTOR(v) ((v).stor_begin) ------------------ 1076| 2.28M| } 1077| 6.06M| } 1078| 188k| j = EDGE(VECTOR(*res)[idx]); ------------------ | | 1049| 188k|# define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 69| 188k|#define VECTOR(v) ((v).stor_begin) | | ------------------ | | # define EDGE(i) (VECTOR(*el)[ VECTOR(*iindex)[(i)] ]) | | ------------------ | | | | 69| 188k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 1079| 452k| for (i = 0; i < no_of_nodes - j; i++) { ------------------ | Branch (1079:21): [True: 264k, False: 188k] ------------------ 1080| 264k| idx++; VECTOR(*res)[idx] = no_of_edges; ------------------ | | 69| 264k|#define VECTOR(v) ((v).stor_begin) ------------------ 1081| 264k| } 1082| 188k| } 1083| | 1084| | /* clean */ 1085| | 1086| 188k|# undef EDGE 1087| 188k| return IGRAPH_SUCCESS; 1088| 188k|} igraph_bfs: 116| 13.8k| void *extra) { 117| | 118| 13.8k| igraph_error_t ret; 119| | 120| 13.8k| igraph_dqueue_int_t Q; 121| 13.8k| igraph_integer_t no_of_nodes = igraph_vcount(graph); 122| 13.8k| igraph_integer_t actroot = 0; 123| 13.8k| igraph_vector_bool_t added; 124| | 125| 13.8k| igraph_lazy_adjlist_t adjlist; 126| | 127| 13.8k| igraph_integer_t act_rank = 0; 128| 13.8k| igraph_integer_t pred_vec = -1; 129| | 130| 13.8k| igraph_integer_t rootpos = 0; 131| 13.8k| igraph_integer_t noroots = roots ? igraph_vector_int_size(roots) : 1; ------------------ | Branch (131:32): [True: 0, False: 13.8k] ------------------ 132| | 133| 13.8k| if (!roots && (root < 0 || root >= no_of_nodes)) { ------------------ | Branch (133:9): [True: 13.8k, False: 0] | Branch (133:20): [True: 0, False: 13.8k] | Branch (133:32): [True: 0, False: 13.8k] ------------------ 134| 0| IGRAPH_ERROR("Invalid root vertex in BFS.", IGRAPH_EINVVID); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 135| 0| } 136| | 137| 13.8k| if (roots && !igraph_vector_int_isininterval(roots, 0, no_of_nodes-1)) { ------------------ | Branch (137:9): [True: 0, False: 13.8k] | Branch (137:18): [True: 0, False: 0] ------------------ 138| 0| IGRAPH_ERROR("Invalid root vertex in BFS.", IGRAPH_EINVVID); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 139| 0| } 140| | 141| 13.8k| if (restricted && !igraph_vector_int_isininterval(restricted, 0, no_of_nodes-1)) { ------------------ | Branch (141:9): [True: 13.8k, False: 0] | Branch (141:23): [True: 0, False: 13.8k] ------------------ 142| 0| IGRAPH_ERROR("Invalid vertex ID in restricted set.", IGRAPH_EINVVID); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 143| 0| } 144| | 145| 13.8k| if (mode != IGRAPH_OUT && mode != IGRAPH_IN && ------------------ | Branch (145:9): [True: 13.8k, False: 0] | Branch (145:31): [True: 0, False: 13.8k] ------------------ 146| 13.8k| mode != IGRAPH_ALL) { ------------------ | Branch (146:9): [True: 0, False: 0] ------------------ 147| 0| IGRAPH_ERROR("Invalid mode argument.", IGRAPH_EINVMODE); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 148| 0| } 149| | 150| 13.8k| if (!igraph_is_directed(graph)) { ------------------ | Branch (150:9): [True: 0, False: 13.8k] ------------------ 151| 0| mode = IGRAPH_ALL; 152| 0| } 153| | 154| 13.8k| IGRAPH_VECTOR_BOOL_INIT_FINALLY(&added, no_of_nodes); ------------------ | | 114| 13.8k| do { IGRAPH_CHECK(igraph_vector_bool_init(v, size)); \ | | ------------------ | | | | 752| 13.8k| do { \ | | | | 753| 13.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 13.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 13.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 115| 13.8k| IGRAPH_FINALLY(igraph_vector_bool_destroy, v); } while (0) | | ------------------ | | | | 695| 13.8k| do { \ | | | | 696| 13.8k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 13.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 13.8k| * incorrect destructor function with the pointer */ \ | | | | 699| 13.8k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 13.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 13.8k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (115:65): [Folded - Ignored] | | ------------------ ------------------ 155| 13.8k| IGRAPH_DQUEUE_INT_INIT_FINALLY(&Q, 100); ------------------ | | 66| 13.8k| do { IGRAPH_CHECK(igraph_dqueue_int_init(q, capacity)); \ | | ------------------ | | | | 752| 13.8k| do { \ | | | | 753| 13.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 13.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 13.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 67| 13.8k| IGRAPH_FINALLY(igraph_dqueue_int_destroy, q); } while (0) | | ------------------ | | | | 695| 13.8k| do { \ | | | | 696| 13.8k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 13.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 13.8k| * incorrect destructor function with the pointer */ \ | | | | 699| 13.8k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 13.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 13.8k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (67:64): [Folded - Ignored] | | ------------------ ------------------ 156| | 157| 13.8k| IGRAPH_CHECK(igraph_lazy_adjlist_init(graph, &adjlist, mode, IGRAPH_LOOPS, IGRAPH_MULTIPLE)); ------------------ | | 752| 13.8k| do { \ | | 753| 13.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 13.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 13.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 158| 13.8k| IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &adjlist); ------------------ | | 695| 13.8k| do { \ | | 696| 13.8k| /* the following branch makes the compiler check the compatibility of \ | | 697| 13.8k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 13.8k| * incorrect destructor function with the pointer */ \ | | 699| 13.8k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 13.8k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 13.8k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 159| | 160| | /* Mark the vertices that are not in the restricted set, as already 161| | found. Special care must be taken for vertices that are not in 162| | the restricted set, but are to be used as 'root' vertices. */ 163| 13.8k| if (restricted) { ------------------ | Branch (163:9): [True: 13.8k, False: 0] ------------------ 164| 13.8k| igraph_integer_t i, n = igraph_vector_int_size(restricted); 165| 13.8k| igraph_vector_bool_fill(&added, true); 166| 82.5k| for (i = 0; i < n; i++) { ------------------ | Branch (166:21): [True: 68.6k, False: 13.8k] ------------------ 167| 68.6k| igraph_integer_t v = VECTOR(*restricted)[i]; ------------------ | | 69| 68.6k|#define VECTOR(v) ((v).stor_begin) ------------------ 168| 68.6k| VECTOR(added)[v] = false; ------------------ | | 69| 68.6k|#define VECTOR(v) ((v).stor_begin) ------------------ 169| 68.6k| } 170| 13.8k| } 171| | 172| | /* Resize result vectors, and fill them with IGRAPH_NAN */ 173| | 174| 13.8k|# define VINIT(v, initial) \ 175| 13.8k| if (v) { \ 176| 13.8k| IGRAPH_CHECK(igraph_vector_int_resize((v), no_of_nodes)); \ 177| 13.8k| igraph_vector_int_fill((v), initial); \ 178| 13.8k| } 179| | 180| 13.8k| VINIT(order, -1); ------------------ | | 175| 13.8k| if (v) { \ | | ------------------ | | | Branch (175:9): [True: 13.8k, False: 0] | | ------------------ | | 176| 13.8k| IGRAPH_CHECK(igraph_vector_int_resize((v), no_of_nodes)); \ | | ------------------ | | | | 752| 13.8k| do { \ | | | | 753| 13.8k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 13.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 13.8k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 177| 13.8k| igraph_vector_int_fill((v), initial); \ | | 178| 13.8k| } ------------------ 181| 13.8k| VINIT(rank, -1); ------------------ | | 175| 13.8k| if (v) { \ | | ------------------ | | | Branch (175:9): [True: 0, False: 13.8k] | | ------------------ | | 176| 0| IGRAPH_CHECK(igraph_vector_int_resize((v), no_of_nodes)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 177| 0| igraph_vector_int_fill((v), initial); \ | | 178| 0| } ------------------ 182| 13.8k| VINIT(parents, -2); ------------------ | | 175| 13.8k| if (v) { \ | | ------------------ | | | Branch (175:9): [True: 0, False: 13.8k] | | ------------------ | | 176| 0| IGRAPH_CHECK(igraph_vector_int_resize((v), no_of_nodes)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 177| 0| igraph_vector_int_fill((v), initial); \ | | 178| 0| } ------------------ 183| 13.8k| VINIT(pred, -2); ------------------ | | 175| 13.8k| if (v) { \ | | ------------------ | | | Branch (175:9): [True: 0, False: 13.8k] | | ------------------ | | 176| 0| IGRAPH_CHECK(igraph_vector_int_resize((v), no_of_nodes)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 177| 0| igraph_vector_int_fill((v), initial); \ | | 178| 0| } ------------------ 184| 13.8k| VINIT(succ, -2); ------------------ | | 175| 13.8k| if (v) { \ | | ------------------ | | | Branch (175:9): [True: 0, False: 13.8k] | | ------------------ | | 176| 0| IGRAPH_CHECK(igraph_vector_int_resize((v), no_of_nodes)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 177| 0| igraph_vector_int_fill((v), initial); \ | | 178| 0| } ------------------ 185| 13.8k| VINIT(dist, -1); ------------------ | | 175| 13.8k| if (v) { \ | | ------------------ | | | Branch (175:9): [True: 0, False: 13.8k] | | ------------------ | | 176| 0| IGRAPH_CHECK(igraph_vector_int_resize((v), no_of_nodes)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 177| 0| igraph_vector_int_fill((v), initial); \ | | 178| 0| } ------------------ 186| 13.8k|# undef VINIT 187| | 188| 27.7k| while (1) { ------------------ | Branch (188:12): [Folded - Ignored] ------------------ 189| | 190| | /* Get the next root vertex, if any */ 191| | 192| 27.7k| if (roots && rootpos < noroots) { ------------------ | Branch (192:13): [True: 0, False: 27.7k] | Branch (192:22): [True: 0, False: 0] ------------------ 193| | /* We are still going through the 'roots' vector */ 194| 0| actroot = VECTOR(*roots)[rootpos++]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 195| 27.7k| } else if (!roots && rootpos == 0) { ------------------ | Branch (195:20): [True: 27.7k, False: 0] | Branch (195:30): [True: 13.8k, False: 13.8k] ------------------ 196| | /* We have a single root vertex given, and start now */ 197| 13.8k| actroot = root; 198| 13.8k| rootpos++; 199| 13.8k| } else if (rootpos == noroots && unreachable) { ------------------ | Branch (199:20): [True: 13.8k, False: 0] | Branch (199:42): [True: 0, False: 13.8k] ------------------ 200| | /* We finished the given root(s), but other vertices are also 201| | tried as root */ 202| 0| actroot = 0; 203| 0| rootpos++; 204| 13.8k| } else if (unreachable && actroot + 1 < no_of_nodes) { ------------------ | Branch (204:20): [True: 0, False: 13.8k] | Branch (204:35): [True: 0, False: 0] ------------------ 205| | /* We are already doing the other vertices, take the next one */ 206| 0| actroot++; 207| 13.8k| } else { 208| | /* No more root nodes to do */ 209| 13.8k| break; 210| 13.8k| } 211| | 212| | /* OK, we have a new root, start BFS */ 213| 13.8k| if (VECTOR(added)[actroot]) { ------------------ | | 69| 13.8k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (213:13): [True: 0, False: 13.8k] ------------------ 214| 0| continue; 215| 0| } 216| 13.8k| IGRAPH_CHECK(igraph_dqueue_int_push(&Q, actroot)); ------------------ | | 752| 13.8k| do { \ | | 753| 13.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 13.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 13.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 217| 13.8k| IGRAPH_CHECK(igraph_dqueue_int_push(&Q, 0)); ------------------ | | 752| 13.8k| do { \ | | 753| 13.8k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 13.8k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 13.8k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 13.8k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 13.8k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 218| 13.8k| VECTOR(added)[actroot] = true; ------------------ | | 69| 13.8k|#define VECTOR(v) ((v).stor_begin) ------------------ 219| 13.8k| if (parents) { ------------------ | Branch (219:13): [True: 0, False: 13.8k] ------------------ 220| 0| VECTOR(*parents)[actroot] = -1; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 221| 0| } 222| | 223| 13.8k| pred_vec = -1; 224| | 225| 29.1k| while (!igraph_dqueue_int_empty(&Q)) { ------------------ | Branch (225:16): [True: 15.2k, False: 13.8k] ------------------ 226| 15.2k| igraph_integer_t actvect = igraph_dqueue_int_pop(&Q); 227| 15.2k| igraph_integer_t actdist = igraph_dqueue_int_pop(&Q); 228| 15.2k| igraph_integer_t succ_vec; 229| 15.2k| igraph_vector_int_t *neis = igraph_lazy_adjlist_get(&adjlist, actvect); ------------------ | | 162| 15.2k| (igraph_lazy_adjlist_has(al,no) ? ((al)->adjs[(igraph_integer_t)(no)]) \ | | ------------------ | | | | 137| 15.2k|#define igraph_lazy_adjlist_has(al,no) ((igraph_bool_t) (al)->adjs[(igraph_integer_t)(no)]) | | | | ------------------ | | | | | Branch (137:40): [True: 0, False: 15.2k] | | | | ------------------ | | ------------------ | | 163| 15.2k| : (igraph_i_lazy_adjlist_get_real(al, no))) ------------------ 230| 15.2k| igraph_integer_t i, n; 231| | 232| 15.2k| IGRAPH_CHECK_OOM(neis, "Failed to query neighbors."); ------------------ | | 807| 15.2k| do { \ | | 808| 15.2k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 15.2k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 15.2k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 15.2k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 233| 15.2k| n = igraph_vector_int_size(neis); 234| | 235| 15.2k| if (pred) { ------------------ | Branch (235:17): [True: 0, False: 15.2k] ------------------ 236| 0| VECTOR(*pred)[actvect] = pred_vec; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 237| 0| } 238| 15.2k| if (rank) { ------------------ | Branch (238:17): [True: 0, False: 15.2k] ------------------ 239| 0| VECTOR(*rank)[actvect] = act_rank; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 240| 0| } 241| 15.2k| if (order) { ------------------ | Branch (241:17): [True: 15.2k, False: 0] ------------------ 242| 15.2k| VECTOR(*order)[act_rank++] = actvect; ------------------ | | 69| 15.2k|#define VECTOR(v) ((v).stor_begin) ------------------ 243| 15.2k| } 244| 15.2k| if (dist) { ------------------ | Branch (244:17): [True: 0, False: 15.2k] ------------------ 245| 0| VECTOR(*dist)[actvect] = actdist; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 246| 0| } 247| | 248| 32.2k| for (i = 0; i < n; i++) { ------------------ | Branch (248:25): [True: 17.0k, False: 15.2k] ------------------ 249| 17.0k| igraph_integer_t nei = VECTOR(*neis)[i]; ------------------ | | 69| 17.0k|#define VECTOR(v) ((v).stor_begin) ------------------ 250| 17.0k| if (! VECTOR(added)[nei]) { ------------------ | | 69| 17.0k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (250:21): [True: 1.39k, False: 15.6k] ------------------ 251| 1.39k| VECTOR(added)[nei] = true; ------------------ | | 69| 1.39k|#define VECTOR(v) ((v).stor_begin) ------------------ 252| 1.39k| IGRAPH_CHECK(igraph_dqueue_int_push(&Q, nei)); ------------------ | | 752| 1.39k| do { \ | | 753| 1.39k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.39k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.39k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.39k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.39k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 253| 1.39k| IGRAPH_CHECK(igraph_dqueue_int_push(&Q, actdist + 1)); ------------------ | | 752| 1.39k| do { \ | | 753| 1.39k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 1.39k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 1.39k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 1.39k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 1.39k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 254| 1.39k| if (parents) { ------------------ | Branch (254:25): [True: 0, False: 1.39k] ------------------ 255| 0| VECTOR(*parents)[nei] = actvect; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 256| 0| } 257| 1.39k| } 258| 17.0k| } 259| | 260| 15.2k| succ_vec = igraph_dqueue_int_empty(&Q) ? -1L : ------------------ | Branch (260:24): [True: 13.8k, False: 1.39k] ------------------ 261| 15.2k| igraph_dqueue_int_head(&Q); 262| 15.2k| if (callback) { ------------------ | Branch (262:17): [True: 0, False: 15.2k] ------------------ 263| 0| IGRAPH_CHECK_CALLBACK( ------------------ | | 785| 0| do { \ | | 786| 0| igraph_error_t igraph_i_ret = (expr); \ | | 787| 0| if (code) { \ | | ------------------ | | | Branch (787:13): [True: 0, False: 0] | | ------------------ | | 788| 0| *(code) = igraph_i_ret; \ | | 789| 0| } \ | | 790| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS && igraph_i_ret != IGRAPH_STOP)) { \ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | | Branch (708:50): [True: 0, False: 0] | | | | | Branch (708:50): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 791| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 792| 0| } \ | | 793| 0| } while (0) | | ------------------ | | | Branch (793:14): [Folded - Ignored] | | ------------------ ------------------ 264| 0| callback(graph, actvect, pred_vec, succ_vec, act_rank - 1, actdist, extra), 265| 0| &ret 266| 0| ); 267| | 268| 0| if (ret == IGRAPH_STOP) { ------------------ | Branch (268:21): [True: 0, False: 0] ------------------ 269| 0| goto cleanup; 270| 0| } 271| 0| } 272| | 273| 15.2k| if (succ) { ------------------ | Branch (273:17): [True: 0, False: 15.2k] ------------------ 274| 0| VECTOR(*succ)[actvect] = succ_vec; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 275| 0| } 276| 15.2k| pred_vec = actvect; 277| | 278| 15.2k| } /* while Q !empty */ 279| | 280| 13.8k| } /* for actroot < no_of_nodes */ 281| | 282| 13.8k|cleanup: 283| | 284| 13.8k| igraph_lazy_adjlist_destroy(&adjlist); 285| 13.8k| igraph_dqueue_int_destroy(&Q); 286| 13.8k| igraph_vector_bool_destroy(&added); 287| 13.8k| IGRAPH_FINALLY_CLEAN(3); 288| | 289| 13.8k| return IGRAPH_SUCCESS; 290| 13.8k|} igraph_qsort: 264| 303k|{ 265| 303k| local_qsort(a, n, es, cmp, NULL); 266| 303k|} qsort.c:local_qsort: 124| 319k|{ 125| 319k| char *pa, *pb, *pc, *pd, *pl, *pm, *pn; 126| 319k| size_t d1, d2; 127| 319k| int cmp_result; 128| 319k| int swap_cnt; 129| | 130| 343k|loop: 131| 343k| swap_cnt = 0; 132| 343k| if (n < 7) { ------------------ | Branch (132:6): [True: 300k, False: 43.2k] ------------------ 133| 856k| for (pm = (char *)a + es; pm < (char *)a + n * es; pm += es) ------------------ | Branch (133:29): [True: 556k, False: 300k] ------------------ 134| 556k| for (pl = pm; 135| 860k| pl > (char *)a && CMP(thunk, pl - es, pl) > 0; ------------------ | | 98| 763k|#define CMP(t, x, y) (cmp((x), (y))) ------------------ | Branch (135:9): [True: 763k, False: 96.9k] | Branch (135:27): [True: 303k, False: 459k] ------------------ 136| 556k| pl -= es) 137| 303k| swapfunc(pl, pl - es, es); 138| 300k| return; 139| 300k| } 140| 43.2k| pm = (char *)a + (n / 2) * es; 141| 43.2k| if (n > 7) { ------------------ | Branch (141:6): [True: 21.4k, False: 21.7k] ------------------ 142| 21.4k| pl = a; 143| 21.4k| pn = (char *)a + (n - 1) * es; 144| 21.4k| if (n > 40) { ------------------ | Branch (144:7): [True: 0, False: 21.4k] ------------------ 145| 0| size_t d = (n / 8) * es; 146| | 147| 0| pl = med3(pl, pl + d, pl + 2 * d, cmp, thunk); 148| 0| pm = med3(pm - d, pm, pm + d, cmp, thunk); 149| 0| pn = med3(pn - 2 * d, pn - d, pn, cmp, thunk); 150| 0| } 151| 21.4k| pm = med3(pl, pm, pn, cmp, thunk); 152| 21.4k| } 153| 43.2k| swapfunc(a, pm, es); 154| 43.2k| pa = pb = (char *)a + es; 155| | 156| 43.2k| pc = pd = (char *)a + (n - 1) * es; 157| 77.0k| for (;;) { 158| 207k| while (pb <= pc && (cmp_result = CMP(thunk, pb, a)) <= 0) { ------------------ | | 98| 190k|#define CMP(t, x, y) (cmp((x), (y))) ------------------ | Branch (158:10): [True: 190k, False: 16.2k] | Branch (158:22): [True: 130k, False: 60.8k] ------------------ 159| 130k| if (cmp_result == 0) { ------------------ | Branch (159:8): [True: 0, False: 130k] ------------------ 160| 0| swap_cnt = 1; 161| 0| swapfunc(pa, pb, es); 162| 0| pa += es; 163| 0| } 164| 130k| pb += es; 165| 130k| } 166| 175k| while (pb <= pc && (cmp_result = CMP(thunk, pc, a)) >= 0) { ------------------ | | 98| 132k|#define CMP(t, x, y) (cmp((x), (y))) ------------------ | Branch (166:10): [True: 132k, False: 43.2k] | Branch (166:22): [True: 98.4k, False: 33.8k] ------------------ 167| 98.4k| if (cmp_result == 0) { ------------------ | Branch (167:8): [True: 0, False: 98.4k] ------------------ 168| 0| swap_cnt = 1; 169| 0| swapfunc(pc, pd, es); 170| 0| pd -= es; 171| 0| } 172| 98.4k| pc -= es; 173| 98.4k| } 174| 77.0k| if (pb > pc) ------------------ | Branch (174:7): [True: 43.2k, False: 33.8k] ------------------ 175| 43.2k| break; 176| 33.8k| swapfunc(pb, pc, es); 177| 33.8k| swap_cnt = 1; 178| 33.8k| pb += es; 179| 33.8k| pc -= es; 180| 33.8k| } 181| 43.2k| if (swap_cnt == 0) { /* Switch to insertion sort */ ------------------ | Branch (181:6): [True: 19.3k, False: 23.9k] ------------------ 182| 147k| for (pm = (char *)a + es; pm < (char *)a + n * es; pm += es) ------------------ | Branch (182:29): [True: 128k, False: 19.3k] ------------------ 183| 128k| for (pl = pm; 184| 289k| pl > (char *)a && CMP(thunk, pl - es, pl) > 0; ------------------ | | 98| 251k|#define CMP(t, x, y) (cmp((x), (y))) ------------------ | Branch (184:9): [True: 251k, False: 37.4k] | Branch (184:27): [True: 160k, False: 90.8k] ------------------ 185| 160k| pl -= es) 186| 160k| swapfunc(pl, pl - es, es); 187| 19.3k| return; 188| 19.3k| } 189| | 190| 23.9k| pn = (char *)a + n * es; 191| 23.9k| d1 = MIN(pa - (char *)a, pb - pa); ------------------ | | 72| 23.9k|#define MIN(a, b) ((a) < (b) ? a : b) | | ------------------ | | | Branch (72:20): [True: 20.1k, False: 3.72k] | | ------------------ ------------------ 192| 23.9k| vecswap(a, pb - d1, d1); ------------------ | | 91| 23.9k| if ((n) > 0) swapfunc(a, b, n) | | ------------------ | | | Branch (91:6): [True: 23.9k, False: 0] | | ------------------ ------------------ 193| | /* 194| | * Cast es to preserve signedness of right-hand side of MIN() 195| | * expression, to avoid sign ambiguity in the implied comparison. es 196| | * is safely within [0, SSIZE_MAX]. 197| | */ 198| 23.9k| d1 = MIN(pd - pc, pn - pd - (ptrdiff_t)es); ------------------ | | 72| 23.9k|#define MIN(a, b) ((a) < (b) ? a : b) | | ------------------ | | | Branch (72:20): [True: 0, False: 23.9k] | | ------------------ ------------------ 199| 23.9k| vecswap(pb, pn - d1, d1); ------------------ | | 91| 23.9k| if ((n) > 0) swapfunc(a, b, n) | | ------------------ | | | Branch (91:6): [True: 0, False: 23.9k] | | ------------------ ------------------ 200| | 201| 23.9k| d1 = pb - pa; 202| 23.9k| d2 = pd - pc; 203| 23.9k| if (d1 <= d2) { ------------------ | Branch (203:6): [True: 11.5k, False: 12.3k] ------------------ 204| | /* Recurse on left partition, then iterate on right partition */ 205| 11.5k| if (d1 > es) { ------------------ | Branch (205:7): [True: 7.78k, False: 3.72k] ------------------ 206| 7.78k| local_qsort(a, d1 / es, es, cmp, thunk); 207| 7.78k| } 208| 11.5k| if (d2 > es) { ------------------ | Branch (208:7): [True: 11.5k, False: 0] ------------------ 209| | /* Iterate rather than recurse to save stack space */ 210| | /* qsort(pn - d2, d2 / es, es, cmp); */ 211| 11.5k| a = pn - d2; 212| 11.5k| n = d2 / es; 213| 11.5k| goto loop; 214| 11.5k| } 215| 12.3k| } else { 216| | /* Recurse on right partition, then iterate on left partition */ 217| 12.3k| if (d2 > es) { ------------------ | Branch (217:7): [True: 8.44k, False: 3.95k] ------------------ 218| 8.44k| local_qsort(pn - d2, d2 / es, es, cmp, thunk); 219| 8.44k| } 220| 12.3k| if (d1 > es) { ------------------ | Branch (220:7): [True: 12.3k, False: 0] ------------------ 221| | /* Iterate rather than recurse to save stack space */ 222| | /* qsort(a, d1 / es, es, cmp); */ 223| 12.3k| n = d1 / es; 224| 12.3k| goto loop; 225| 12.3k| } 226| 12.3k| } 227| 23.9k|} qsort.c:swapfunc: 80| 565k|{ 81| 565k| char t; 82| | 83| 4.52M| do { 84| 4.52M| t = *a; 85| 4.52M| *a++ = *b; 86| 4.52M| *b++ = t; 87| 4.52M| } while (--es > 0); ------------------ | Branch (87:11): [True: 3.95M, False: 565k] ------------------ 88| 565k|} qsort.c:med3: 107| 21.4k|{ 108| 21.4k| return CMP(thunk, a, b) < 0 ? ------------------ | | 98| 21.4k|#define CMP(t, x, y) (cmp((x), (y))) ------------------ | Branch (108:9): [True: 18.7k, False: 2.78k] ------------------ 109| 18.7k| (CMP(thunk, b, c) < 0 ? b : (CMP(thunk, a, c) < 0 ? c : a )) ------------------ | | 98| 18.7k|#define CMP(t, x, y) (cmp((x), (y))) ------------------ (CMP(thunk, b, c) < 0 ? b : (CMP(thunk, a, c) < 0 ? c : a )) ------------------ | | 98| 8.03k|#define CMP(t, x, y) (cmp((x), (y))) ------------------ | Branch (109:10): [True: 10.6k, False: 8.03k] | Branch (109:38): [True: 6.62k, False: 1.40k] ------------------ 110| 21.4k| :(CMP(thunk, b, c) > 0 ? b : (CMP(thunk, a, c) < 0 ? a : c )); ------------------ | | 98| 2.78k|#define CMP(t, x, y) (cmp((x), (y))) ------------------ :(CMP(thunk, b, c) > 0 ? b : (CMP(thunk, a, c) < 0 ? a : c )); ------------------ | | 98| 2.21k|#define CMP(t, x, y) (cmp((x), (y))) ------------------ | Branch (110:10): [True: 574, False: 2.21k] | Branch (110:38): [True: 1.63k, False: 575] ------------------ 111| 21.4k|} igraph_get_edgelist: 334| 45.5k|igraph_error_t igraph_get_edgelist(const igraph_t *graph, igraph_vector_int_t *res, igraph_bool_t bycol) { 335| | 336| 45.5k| igraph_eit_t edgeit; 337| 45.5k| igraph_integer_t no_of_edges = igraph_ecount(graph); 338| 45.5k| igraph_integer_t vptr = 0; 339| 45.5k| igraph_integer_t from, to; 340| | 341| 45.5k| IGRAPH_CHECK(igraph_vector_int_resize(res, no_of_edges * 2)); ------------------ | | 752| 45.5k| do { \ | | 753| 45.5k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 45.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 45.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 45.5k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 45.5k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 342| 45.5k| IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_ID), ------------------ | | 752| 45.5k| do { \ | | 753| 45.5k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 45.5k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 45.5k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 45.5k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 45.5k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 343| 45.5k| &edgeit)); 344| 45.5k| IGRAPH_FINALLY(igraph_eit_destroy, &edgeit); ------------------ | | 695| 45.5k| do { \ | | 696| 45.5k| /* the following branch makes the compiler check the compatibility of \ | | 697| 45.5k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 45.5k| * incorrect destructor function with the pointer */ \ | | 699| 45.5k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 45.5k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 45.5k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 345| | 346| 45.5k| if (bycol) { ------------------ | Branch (346:9): [True: 0, False: 45.5k] ------------------ 347| 0| while (!IGRAPH_EIT_END(edgeit)) { ------------------ | | 376| 0|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end) ------------------ | Branch (347:16): [True: 0, False: 0] ------------------ 348| 0| igraph_edge(graph, IGRAPH_EIT_GET(edgeit), &from, &to); ------------------ | | 410| 0| (igraph_integer_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \ | | ------------------ | | | Branch (410:25): [True: 0, False: 0] | | ------------------ | | 411| 0| VECTOR(*(eit).vec)[(eit).pos])) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 349| 0| VECTOR(*res)[vptr] = from; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 350| 0| VECTOR(*res)[vptr + no_of_edges] = to; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 351| 0| vptr++; 352| 0| IGRAPH_EIT_NEXT(edgeit); ------------------ | | 364| 0|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos)) ------------------ 353| 0| } 354| 45.5k| } else { 355| 3.18M| while (!IGRAPH_EIT_END(edgeit)) { ------------------ | | 376| 3.18M|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end) ------------------ | Branch (355:16): [True: 3.13M, False: 45.5k] ------------------ 356| 3.13M| igraph_edge(graph, IGRAPH_EIT_GET(edgeit), &from, &to); ------------------ | | 410| 3.13M| (igraph_integer_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \ | | ------------------ | | | Branch (410:25): [True: 3.13M, False: 0] | | ------------------ | | 411| 3.13M| VECTOR(*(eit).vec)[(eit).pos])) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 357| 3.13M| VECTOR(*res)[vptr++] = from; ------------------ | | 69| 3.13M|#define VECTOR(v) ((v).stor_begin) ------------------ 358| 3.13M| VECTOR(*res)[vptr++] = to; ------------------ | | 69| 3.13M|#define VECTOR(v) ((v).stor_begin) ------------------ 359| 3.13M| IGRAPH_EIT_NEXT(edgeit); ------------------ | | 364| 3.13M|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos)) ------------------ 360| 3.13M| } 361| 45.5k| } 362| | 363| 45.5k| igraph_eit_destroy(&edgeit); 364| 45.5k| IGRAPH_FINALLY_CLEAN(1); 365| 45.5k| return IGRAPH_SUCCESS; 366| 45.5k|} igraph_to_directed: 400| 837| igraph_to_directed_t mode) { 401| 837| igraph_integer_t no_of_edges = igraph_ecount(graph); 402| 837| igraph_integer_t no_of_nodes = igraph_vcount(graph); 403| | 404| 837| if (igraph_is_directed(graph)) { ------------------ | Branch (404:9): [True: 0, False: 837] ------------------ 405| 0| return IGRAPH_SUCCESS; 406| 0| } 407| | 408| 837| switch (mode) { 409| 0| case IGRAPH_TO_DIRECTED_ARBITRARY: ------------------ | Branch (409:5): [True: 0, False: 837] ------------------ 410| 0| case IGRAPH_TO_DIRECTED_RANDOM: ------------------ | Branch (410:5): [True: 0, False: 837] ------------------ 411| 0| case IGRAPH_TO_DIRECTED_ACYCLIC: ------------------ | Branch (411:5): [True: 0, False: 837] ------------------ 412| 0| { 413| 0| igraph_t newgraph; 414| 0| igraph_vector_int_t edges; 415| 0| igraph_integer_t size = no_of_edges * 2; 416| | 417| 0| IGRAPH_VECTOR_INT_INIT_FINALLY(&edges, size); ------------------ | | 124| 0| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 0| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 0| do { \ | | | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 0| * incorrect destructor function with the pointer */ \ | | | | 699| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 0| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 418| 0| IGRAPH_CHECK(igraph_get_edgelist(graph, &edges, 0)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 419| | 420| 0| if (mode == IGRAPH_TO_DIRECTED_RANDOM) { ------------------ | Branch (420:13): [True: 0, False: 0] ------------------ 421| 0| RNG_BEGIN(); ------------------ | | 169| 0| do { if (!igraph_rng_default()->is_seeded) { \ | | ------------------ | | | Branch (169:14): [True: 0, False: 0] | | ------------------ | | 170| 0| igraph_rng_seed(igraph_rng_default(), time(0)); \ | | 171| 0| igraph_rng_default()->is_seeded = 1; \ | | 172| 0| } } while (0) | | ------------------ | | | Branch (172:16): [Folded - Ignored] | | ------------------ ------------------ 422| | 423| 0| for (igraph_integer_t i=0; i < no_of_edges; ++i) { ------------------ | Branch (423:40): [True: 0, False: 0] ------------------ 424| 0| if (RNG_INTEGER(0,1)) { ------------------ | | 177| 0|#define RNG_INTEGER(l,h) (igraph_rng_get_integer(igraph_rng_default(),(l),(h))) | | ------------------ | | | Branch (177:26): [True: 0, False: 0] | | ------------------ ------------------ 425| 0| igraph_integer_t temp = VECTOR(edges)[2*i]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 426| 0| VECTOR(edges)[2*i] = VECTOR(edges)[2*i+1]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(edges)[2*i] = VECTOR(edges)[2*i+1]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 427| 0| VECTOR(edges)[2*i+1] = temp; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 428| 0| } 429| 0| } 430| | 431| 0| RNG_END(); ------------------ | | 174| 0| do { /* nothing */ } while (0) | | ------------------ | | | Branch (174:33): [Folded - Ignored] | | ------------------ ------------------ 432| 0| } else if (mode == IGRAPH_TO_DIRECTED_ACYCLIC) { ------------------ | Branch (432:20): [True: 0, False: 0] ------------------ 433| | /* Currently, the endpoints of undirected edges are ordered in the 434| | internal graph datastructure, i.e. it is always true that from < to. 435| | However, it is not guaranteed that this will not be changed in 436| | the future, and this ordering should not be relied on outside of 437| | the implementation of the minimal API in type_indexededgelist.c. 438| | 439| | Therefore, we order the edge endpoints anyway in the following loop: */ 440| 0| for (igraph_integer_t i=0; i < no_of_edges; ++i) { ------------------ | Branch (440:40): [True: 0, False: 0] ------------------ 441| 0| if (VECTOR(edges)[2*i] > VECTOR(edges)[2*i+1]) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ if (VECTOR(edges)[2*i] > VECTOR(edges)[2*i+1]) { ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (441:21): [True: 0, False: 0] ------------------ 442| 0| igraph_integer_t temp = VECTOR(edges)[2*i]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 443| 0| VECTOR(edges)[2*i] = VECTOR(edges)[2*i+1]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(edges)[2*i] = VECTOR(edges)[2*i+1]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 444| 0| VECTOR(edges)[2*i+1] = temp; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 445| 0| } 446| 0| } 447| 0| } 448| | 449| 0| IGRAPH_CHECK(igraph_create(&newgraph, &edges, ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 450| 0| no_of_nodes, 451| 0| IGRAPH_DIRECTED)); 452| 0| IGRAPH_FINALLY(igraph_destroy, &newgraph); ------------------ | | 695| 0| do { \ | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 0| * incorrect destructor function with the pointer */ \ | | 699| 0| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 0| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 453| 0| IGRAPH_I_ATTRIBUTE_DESTROY(&newgraph); ------------------ | | 30| 0| do {if ((graph)->attr) igraph_i_attribute_destroy(graph);} while(0) | | ------------------ | | | Branch (30:13): [True: 0, False: 0] | | | Branch (30:70): [Folded - Ignored] | | ------------------ ------------------ 454| 0| IGRAPH_I_ATTRIBUTE_COPY(&newgraph, graph, true, true, true); ------------------ | | 31| 0|#define IGRAPH_I_ATTRIBUTE_COPY(to,from,ga,va,ea) do { \ | | 32| 0| igraph_error_t igraph_i_ret2=IGRAPH_SUCCESS; \ | | 33| 0| if ((from)->attr) { \ | | ------------------ | | | Branch (33:13): [True: 0, False: 0] | | ------------------ | | 34| 0| IGRAPH_CHECK(igraph_i_ret2=igraph_i_attribute_copy((to),(from),(ga),(va),(ea))); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 35| 0| } else { \ | | 36| 0| (to)->attr = NULL; \ | | 37| 0| } \ | | 38| 0| if (igraph_i_ret2 != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (38:13): [True: 0, False: 0] | | ------------------ | | 39| 0| IGRAPH_ERROR("", igraph_i_ret2); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 40| 0| } \ | | 41| 0| } while(0) | | ------------------ | | | Branch (41:13): [Folded - Ignored] | | ------------------ ------------------ 455| 0| igraph_vector_int_destroy(&edges); 456| 0| IGRAPH_FINALLY_CLEAN(2); 457| | 458| 0| igraph_destroy(graph); 459| 0| *graph = newgraph; 460| | 461| 0| break; 462| 0| } 463| 837| case IGRAPH_TO_DIRECTED_MUTUAL: ------------------ | Branch (463:5): [True: 837, False: 0] ------------------ 464| 837| { 465| 837| igraph_t newgraph; 466| 837| igraph_vector_int_t edges; 467| 837| igraph_vector_int_t index; 468| 837| igraph_integer_t size; 469| | 470| 837| IGRAPH_SAFE_MULT(no_of_edges, 4, &size); ------------------ | | 57| 837| do { \ | | 58| 837| igraph_integer_t _safe_a = (a), _safe_b = (b); \ | | 59| 837| igraph_integer_t _safe_prod; \ | | 60| 837| if (__builtin_mul_overflow(_safe_a, _safe_b, &_safe_prod)) { \ | | ------------------ | | | Branch (60:13): [True: 0, False: 837] | | ------------------ | | 61| 0| IGRAPH_ERRORF("Overflow when multiplying %" IGRAPH_PRId " and %" IGRAPH_PRId ".", IGRAPH_EOVERFLOW, _safe_a, _safe_b); \ | | ------------------ | | | | 550| 0| do { \ | | | | 551| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | | | 552| 0| igraph_errno, __VA_ARGS__) ; \ | | | | 553| 0| return igraph_errno; \ | | | | 554| 0| } while (0) | | | | ------------------ | | | | | Branch (554:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 62| 0| } \ | | 63| 837| *(res) = _safe_prod; \ | | 64| 837| } while (0) | | ------------------ | | | Branch (64:14): [Folded - Ignored] | | ------------------ ------------------ 471| 837| IGRAPH_VECTOR_INT_INIT_FINALLY(&edges, 0); ------------------ | | 124| 837| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 837| do { \ | | | | 753| 837| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 837| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 837] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 837| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 837| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 837| do { \ | | | | 696| 837| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 837| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 837| * incorrect destructor function with the pointer */ \ | | | | 699| 837| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 837| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 837| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 472| 837| IGRAPH_CHECK(igraph_vector_int_reserve(&edges, size)); ------------------ | | 752| 837| do { \ | | 753| 837| igraph_error_t igraph_i_ret = (expr); \ | | 754| 837| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 837] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 837| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 473| 837| IGRAPH_CHECK(igraph_get_edgelist(graph, &edges, 0)); ------------------ | | 752| 837| do { \ | | 753| 837| igraph_error_t igraph_i_ret = (expr); \ | | 754| 837| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 837] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 837| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 474| 837| IGRAPH_CHECK(igraph_vector_int_resize(&edges, size)); ------------------ | | 752| 837| do { \ | | 753| 837| igraph_error_t igraph_i_ret = (expr); \ | | 754| 837| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 837] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 837| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 475| 837| IGRAPH_VECTOR_INT_INIT_FINALLY(&index, no_of_edges * 2); ------------------ | | 124| 837| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 837| do { \ | | | | 753| 837| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 837| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 837] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 837| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 837| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 837| do { \ | | | | 696| 837| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 837| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 837| * incorrect destructor function with the pointer */ \ | | | | 699| 837| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 837| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 837| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 476| 18.8k| for (igraph_integer_t i = 0; i < no_of_edges; i++) { ------------------ | Branch (476:38): [True: 17.9k, False: 837] ------------------ 477| 17.9k| VECTOR(edges)[no_of_edges * 2 + i * 2] = VECTOR(edges)[i * 2 + 1]; ------------------ | | 69| 17.9k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(edges)[no_of_edges * 2 + i * 2] = VECTOR(edges)[i * 2 + 1]; ------------------ | | 69| 17.9k|#define VECTOR(v) ((v).stor_begin) ------------------ 478| 17.9k| VECTOR(edges)[no_of_edges * 2 + i * 2 + 1] = VECTOR(edges)[i * 2]; ------------------ | | 69| 17.9k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(edges)[no_of_edges * 2 + i * 2 + 1] = VECTOR(edges)[i * 2]; ------------------ | | 69| 17.9k|#define VECTOR(v) ((v).stor_begin) ------------------ 479| 17.9k| VECTOR(index)[i] = VECTOR(index)[no_of_edges + i] = i; ------------------ | | 69| 17.9k|#define VECTOR(v) ((v).stor_begin) ------------------ VECTOR(index)[i] = VECTOR(index)[no_of_edges + i] = i; ------------------ | | 69| 17.9k|#define VECTOR(v) ((v).stor_begin) ------------------ 480| 17.9k| } 481| | 482| 837| IGRAPH_CHECK(igraph_create(&newgraph, &edges, ------------------ | | 752| 837| do { \ | | 753| 837| igraph_error_t igraph_i_ret = (expr); \ | | 754| 837| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 837] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 837| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 483| 837| no_of_nodes, 484| 837| IGRAPH_DIRECTED)); 485| 837| IGRAPH_FINALLY(igraph_destroy, &newgraph); ------------------ | | 695| 837| do { \ | | 696| 837| /* the following branch makes the compiler check the compatibility of \ | | 697| 837| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 837| * incorrect destructor function with the pointer */ \ | | 699| 837| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 837| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 837| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 486| 837| IGRAPH_I_ATTRIBUTE_DESTROY(&newgraph); ------------------ | | 30| 837| do {if ((graph)->attr) igraph_i_attribute_destroy(graph);} while(0) | | ------------------ | | | Branch (30:13): [True: 0, False: 837] | | | Branch (30:70): [Folded - Ignored] | | ------------------ ------------------ 487| 837| IGRAPH_I_ATTRIBUTE_COPY(&newgraph, graph, true, true, /*edges=*/false); ------------------ | | 31| 837|#define IGRAPH_I_ATTRIBUTE_COPY(to,from,ga,va,ea) do { \ | | 32| 837| igraph_error_t igraph_i_ret2=IGRAPH_SUCCESS; \ | | 33| 837| if ((from)->attr) { \ | | ------------------ | | | Branch (33:13): [True: 0, False: 837] | | ------------------ | | 34| 0| IGRAPH_CHECK(igraph_i_ret2=igraph_i_attribute_copy((to),(from),(ga),(va),(ea))); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 35| 837| } else { \ | | 36| 837| (to)->attr = NULL; \ | | 37| 837| } \ | | 38| 837| if (igraph_i_ret2 != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (38:13): [True: 0, False: 837] | | ------------------ | | 39| 0| IGRAPH_ERROR("", igraph_i_ret2); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 40| 0| } \ | | 41| 837| } while(0) | | ------------------ | | | Branch (41:13): [Folded - Ignored] | | ------------------ ------------------ 488| 837| IGRAPH_CHECK(igraph_i_attribute_permute_edges(graph, &newgraph, &index)); ------------------ | | 752| 837| do { \ | | 753| 837| igraph_error_t igraph_i_ret = (expr); \ | | 754| 837| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 837| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 837] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 837| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 489| | 490| 837| igraph_vector_int_destroy(&index); 491| 837| igraph_vector_int_destroy(&edges); 492| 837| IGRAPH_FINALLY_CLEAN(3); 493| | 494| 837| igraph_destroy(graph); 495| 837| *graph = newgraph; 496| | 497| 837| break; 498| 837| } 499| 0| default: ------------------ | Branch (499:5): [True: 0, False: 837] ------------------ 500| 0| IGRAPH_ERROR("Cannot direct graph, invalid mode.", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 501| 837| } 502| | 503| 837| return IGRAPH_SUCCESS; 504| 837|} igraph_add_edge: 51| 27.0k|igraph_error_t igraph_add_edge(igraph_t *graph, igraph_integer_t from, igraph_integer_t to) { 52| 27.0k| igraph_vector_int_t edges; 53| | 54| 27.0k| IGRAPH_VECTOR_INT_INIT_FINALLY(&edges, 2); ------------------ | | 124| 27.0k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 27.0k| do { \ | | | | 753| 27.0k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 27.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 27.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 27.0k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 27.0k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 27.0k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 27.0k| do { \ | | | | 696| 27.0k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 27.0k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 27.0k| * incorrect destructor function with the pointer */ \ | | | | 699| 27.0k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 27.0k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 27.0k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 55| | 56| 27.0k| VECTOR(edges)[0] = from; ------------------ | | 69| 27.0k|#define VECTOR(v) ((v).stor_begin) ------------------ 57| 27.0k| VECTOR(edges)[1] = to; ------------------ | | 69| 27.0k|#define VECTOR(v) ((v).stor_begin) ------------------ 58| 27.0k| IGRAPH_CHECK(igraph_add_edges(graph, &edges, 0)); ------------------ | | 752| 27.0k| do { \ | | 753| 27.0k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 27.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 27.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 27.0k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 27.0k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 59| | 60| 27.0k| igraph_vector_int_destroy(&edges); 61| 27.0k| IGRAPH_FINALLY_CLEAN(1); 62| 27.0k| return IGRAPH_SUCCESS; 63| 27.0k|} igraph_contract_vertices: 63| 5.36k| const igraph_attribute_combination_t *vertex_comb) { 64| 5.36k| igraph_vector_int_t edges; 65| 5.36k| igraph_integer_t no_of_nodes = igraph_vcount(graph); 66| 5.36k| igraph_integer_t no_of_edges = igraph_ecount(graph); 67| 5.36k| igraph_bool_t vattr = vertex_comb && igraph_has_attribute_table(); ------------------ | Branch (67:27): [True: 0, False: 5.36k] | Branch (67:42): [True: 0, False: 0] ------------------ 68| 5.36k| igraph_t res; 69| 5.36k| igraph_integer_t e, last = -1; 70| 5.36k| igraph_integer_t no_new_vertices; 71| | 72| 5.36k| if (igraph_vector_int_size(mapping) != no_of_nodes) { ------------------ | Branch (72:9): [True: 0, False: 5.36k] ------------------ 73| 0| IGRAPH_ERRORF("Mapping vector length (%" IGRAPH_PRId ") " ------------------ | | 550| 0| do { \ | | 551| 0| igraph_errorf(reason, IGRAPH_FILE_BASENAME, __LINE__, \ | | 552| 0| igraph_errno, __VA_ARGS__) ; \ | | 553| 0| return igraph_errno; \ | | 554| 0| } while (0) | | ------------------ | | | Branch (554:14): [Folded - Ignored] | | ------------------ ------------------ 74| 0| "not equal to number of nodes (%" IGRAPH_PRId ").", 75| 0| IGRAPH_EINVAL, igraph_vector_int_size(mapping), no_of_nodes); 76| 0| } 77| | 78| 5.36k| IGRAPH_VECTOR_INT_INIT_FINALLY(&edges, 0); ------------------ | | 124| 5.36k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 5.36k| do { \ | | | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 5.36k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 5.36k| do { \ | | | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | | | 699| 5.36k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 5.36k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 79| 5.36k| IGRAPH_CHECK(igraph_vector_int_reserve(&edges, no_of_edges * 2)); ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 80| | 81| 5.36k| if (no_of_nodes > 0) { ------------------ | Branch (81:9): [True: 5.36k, False: 0] ------------------ 82| 5.36k| last = igraph_vector_int_max(mapping); 83| 5.36k| } 84| | 85| 371k| for (e = 0; e < no_of_edges; e++) { ------------------ | Branch (85:17): [True: 365k, False: 5.36k] ------------------ 86| 365k| igraph_integer_t from = IGRAPH_FROM(graph, e); ------------------ | | 103| 365k|#define IGRAPH_FROM(graph,eid) ((igraph_integer_t)(VECTOR((graph)->from)[(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 365k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 87| 365k| igraph_integer_t to = IGRAPH_TO(graph, e); ------------------ | | 116| 365k|#define IGRAPH_TO(graph,eid) ((igraph_integer_t)(VECTOR((graph)->to) [(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 365k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 88| | 89| 365k| igraph_integer_t nfrom = VECTOR(*mapping)[from]; ------------------ | | 69| 365k|#define VECTOR(v) ((v).stor_begin) ------------------ 90| 365k| igraph_integer_t nto = VECTOR(*mapping)[to]; ------------------ | | 69| 365k|#define VECTOR(v) ((v).stor_begin) ------------------ 91| | 92| 365k| igraph_vector_int_push_back(&edges, nfrom); 93| 365k| igraph_vector_int_push_back(&edges, nto); 94| | 95| 365k| if (nfrom > last) { ------------------ | Branch (95:13): [True: 0, False: 365k] ------------------ 96| 0| last = nfrom; 97| 0| } 98| 365k| if (nto > last) { ------------------ | Branch (98:13): [True: 0, False: 365k] ------------------ 99| 0| last = nto; 100| 0| } 101| 365k| } 102| | 103| 5.36k| no_new_vertices = last + 1; 104| | 105| 5.36k| IGRAPH_CHECK(igraph_create(&res, &edges, no_new_vertices, ------------------ | | 752| 5.36k| do { \ | | 753| 5.36k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 5.36k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 5.36k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 5.36k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 5.36k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 106| 5.36k| igraph_is_directed(graph))); 107| | 108| 5.36k| igraph_vector_int_destroy(&edges); 109| 5.36k| IGRAPH_FINALLY_CLEAN(1); 110| | 111| 5.36k| IGRAPH_FINALLY(igraph_destroy, &res); ------------------ | | 695| 5.36k| do { \ | | 696| 5.36k| /* the following branch makes the compiler check the compatibility of \ | | 697| 5.36k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 5.36k| * incorrect destructor function with the pointer */ \ | | 699| 5.36k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 5.36k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 5.36k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 112| | 113| 5.36k| IGRAPH_I_ATTRIBUTE_DESTROY(&res); ------------------ | | 30| 5.36k| do {if ((graph)->attr) igraph_i_attribute_destroy(graph);} while(0) | | ------------------ | | | Branch (30:13): [True: 0, False: 5.36k] | | | Branch (30:70): [Folded - Ignored] | | ------------------ ------------------ 114| 5.36k| IGRAPH_I_ATTRIBUTE_COPY(&res, graph, /*graph=*/ 1, ------------------ | | 31| 5.36k|#define IGRAPH_I_ATTRIBUTE_COPY(to,from,ga,va,ea) do { \ | | 32| 5.36k| igraph_error_t igraph_i_ret2=IGRAPH_SUCCESS; \ | | 33| 5.36k| if ((from)->attr) { \ | | ------------------ | | | Branch (33:13): [True: 0, False: 5.36k] | | ------------------ | | 34| 0| IGRAPH_CHECK(igraph_i_ret2=igraph_i_attribute_copy((to),(from),(ga),(va),(ea))); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 35| 5.36k| } else { \ | | 36| 5.36k| (to)->attr = NULL; \ | | 37| 5.36k| } \ | | 38| 5.36k| if (igraph_i_ret2 != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (38:13): [True: 0, False: 5.36k] | | ------------------ | | 39| 0| IGRAPH_ERROR("", igraph_i_ret2); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 40| 0| } \ | | 41| 5.36k| } while(0) | | ------------------ | | | Branch (41:13): [Folded - Ignored] | | ------------------ ------------------ 115| 5.36k| /*vertex=*/ 0, /*edge=*/ 1); 116| | 117| 5.36k| if (vattr) { ------------------ | Branch (117:9): [True: 0, False: 5.36k] ------------------ 118| 0| igraph_integer_t i; 119| 0| igraph_vector_int_list_t merges; 120| 0| igraph_vector_int_t sizes; 121| | 122| 0| IGRAPH_VECTOR_INT_LIST_INIT_FINALLY(&merges, no_new_vertices); ------------------ | | 68| 0| do { IGRAPH_CHECK(igraph_vector_int_list_init(v, size)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 69| 0| IGRAPH_FINALLY(igraph_vector_int_list_destroy, v); } while (0) | | ------------------ | | | | 695| 0| do { \ | | | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 0| * incorrect destructor function with the pointer */ \ | | | | 699| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 0| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (69:69): [Folded - Ignored] | | ------------------ ------------------ 123| 0| IGRAPH_VECTOR_INT_INIT_FINALLY(&sizes, no_new_vertices); ------------------ | | 124| 0| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 0| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 0| do { \ | | | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 0| * incorrect destructor function with the pointer */ \ | | | | 699| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 0| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 124| | 125| 0| for (i = 0; i < no_of_nodes; i++) { ------------------ | Branch (125:21): [True: 0, False: 0] ------------------ 126| 0| igraph_integer_t to = VECTOR(*mapping)[i]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 127| 0| igraph_vector_int_t *v = igraph_vector_int_list_get_ptr(&merges, to); 128| 0| VECTOR(sizes)[to] += 1; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 129| 0| IGRAPH_CHECK(igraph_vector_int_push_back(v, i)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 130| 0| } 131| | 132| 0| IGRAPH_CHECK(igraph_i_attribute_combine_vertices(graph, &res, ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 133| 0| &merges, 134| 0| vertex_comb)); 135| | 136| 0| igraph_vector_int_destroy(&sizes); 137| 0| igraph_vector_int_list_destroy(&merges); 138| 0| IGRAPH_FINALLY_CLEAN(2); 139| 0| } 140| | 141| 5.36k| IGRAPH_FINALLY_CLEAN(1); 142| 5.36k| igraph_destroy(graph); 143| 5.36k| *graph = res; 144| | 145| 5.36k| return IGRAPH_SUCCESS; 146| 5.36k|} igraph_simplify: 57| 6.07k| const igraph_attribute_combination_t *edge_comb) { 58| | 59| 6.07k| igraph_vector_int_t edges; 60| 6.07k| igraph_integer_t no_of_nodes = igraph_vcount(graph); 61| 6.07k| igraph_integer_t no_of_edges = igraph_ecount(graph); 62| 6.07k| igraph_integer_t edge; 63| 6.07k| igraph_bool_t attr = edge_comb && igraph_has_attribute_table(); ------------------ | Branch (63:26): [True: 0, False: 6.07k] | Branch (63:39): [True: 0, False: 0] ------------------ 64| 6.07k| igraph_integer_t from, to, pfrom = -1, pto = -2; 65| 6.07k| igraph_t res; 66| 6.07k| igraph_es_t es; 67| 6.07k| igraph_eit_t eit; 68| 6.07k| igraph_vector_int_t mergeinto; 69| 6.07k| igraph_integer_t actedge; 70| | 71| | /* if we already know there are no multi-edges, they don't need to be removed */ 72| 6.07k| if (igraph_i_property_cache_has(graph, IGRAPH_PROP_HAS_MULTI) && ------------------ | Branch (72:9): [True: 0, False: 6.07k] ------------------ 73| 6.07k| !igraph_i_property_cache_get_bool(graph, IGRAPH_PROP_HAS_MULTI)) { ------------------ | Branch (73:9): [True: 0, False: 0] ------------------ 74| 0| multiple = false; 75| 0| } 76| | 77| | /* if we already know there are no loops, they don't need to be removed */ 78| 6.07k| if (igraph_i_property_cache_has(graph, IGRAPH_PROP_HAS_LOOP) && ------------------ | Branch (78:9): [True: 0, False: 6.07k] ------------------ 79| 6.07k| !igraph_i_property_cache_get_bool(graph, IGRAPH_PROP_HAS_LOOP)) { ------------------ | Branch (79:9): [True: 0, False: 0] ------------------ 80| 0| loops = false; 81| 0| } 82| | 83| 6.07k| if (!multiple && !loops) ------------------ | Branch (83:9): [True: 0, False: 6.07k] | Branch (83:22): [True: 0, False: 0] ------------------ 84| | /* nothing to do */ 85| 0| { 86| 0| return IGRAPH_SUCCESS; 87| 0| } 88| | 89| 6.07k| if (!multiple) { ------------------ | Branch (89:9): [True: 0, False: 6.07k] ------------------ 90| 0| igraph_vector_int_t edges_to_delete; 91| | 92| | /* removing loop edges only, this is simple. No need to combine anything 93| | * and the whole process can be done in-place */ 94| 0| IGRAPH_VECTOR_INT_INIT_FINALLY(&edges_to_delete, 0); ------------------ | | 124| 0| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 0| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 0| do { \ | | | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 0| * incorrect destructor function with the pointer */ \ | | | | 699| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 0| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 95| 0| IGRAPH_CHECK(igraph_es_all(&es, IGRAPH_EDGEORDER_ID)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 96| 0| IGRAPH_FINALLY(igraph_es_destroy, &es); ------------------ | | 695| 0| do { \ | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 0| * incorrect destructor function with the pointer */ \ | | 699| 0| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 0| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 97| 0| IGRAPH_CHECK(igraph_eit_create(graph, es, &eit)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 98| 0| IGRAPH_FINALLY(igraph_eit_destroy, &eit); ------------------ | | 695| 0| do { \ | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 0| * incorrect destructor function with the pointer */ \ | | 699| 0| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 0| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 99| | 100| 0| while (!IGRAPH_EIT_END(eit)) { ------------------ | | 376| 0|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end) ------------------ | Branch (100:16): [True: 0, False: 0] ------------------ 101| 0| edge = IGRAPH_EIT_GET(eit); ------------------ | | 410| 0| (igraph_integer_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \ | | ------------------ | | | Branch (410:25): [True: 0, False: 0] | | ------------------ | | 411| 0| VECTOR(*(eit).vec)[(eit).pos])) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 102| 0| from = IGRAPH_FROM(graph, edge); ------------------ | | 103| 0|#define IGRAPH_FROM(graph,eid) ((igraph_integer_t)(VECTOR((graph)->from)[(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 103| 0| to = IGRAPH_TO(graph, edge); ------------------ | | 116| 0|#define IGRAPH_TO(graph,eid) ((igraph_integer_t)(VECTOR((graph)->to) [(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 104| 0| if (from == to) { ------------------ | Branch (104:17): [True: 0, False: 0] ------------------ 105| 0| IGRAPH_CHECK(igraph_vector_int_push_back(&edges_to_delete, edge)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 106| 0| } 107| 0| IGRAPH_EIT_NEXT(eit); ------------------ | | 364| 0|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos)) ------------------ 108| 0| } 109| | 110| 0| igraph_eit_destroy(&eit); 111| 0| igraph_es_destroy(&es); 112| 0| IGRAPH_FINALLY_CLEAN(2); 113| | 114| 0| if (igraph_vector_int_size(&edges_to_delete) > 0) { ------------------ | Branch (114:13): [True: 0, False: 0] ------------------ 115| 0| IGRAPH_CHECK(igraph_delete_edges(graph, igraph_ess_vector(&edges_to_delete))); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 116| 0| } 117| | 118| 0| igraph_vector_int_destroy(&edges_to_delete); 119| 0| IGRAPH_FINALLY_CLEAN(1); 120| | 121| 0| igraph_i_property_cache_set_bool(graph, IGRAPH_PROP_HAS_LOOP, false); 122| | 123| 0| return IGRAPH_SUCCESS; 124| 0| } 125| | 126| 6.07k| if (attr) { ------------------ | Branch (126:9): [True: 0, False: 6.07k] ------------------ 127| 0| IGRAPH_VECTOR_INT_INIT_FINALLY(&mergeinto, no_of_edges); ------------------ | | 124| 0| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 0| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 0| do { \ | | | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 0| * incorrect destructor function with the pointer */ \ | | | | 699| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 0| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 128| 0| } 129| 6.07k| IGRAPH_VECTOR_INT_INIT_FINALLY(&edges, 0); ------------------ | | 124| 6.07k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 6.07k| do { \ | | | | 753| 6.07k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 6.07k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 6.07k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 6.07k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 6.07k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 6.07k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 6.07k| do { \ | | | | 696| 6.07k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 6.07k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 6.07k| * incorrect destructor function with the pointer */ \ | | | | 699| 6.07k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 6.07k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 6.07k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 130| 6.07k| IGRAPH_CHECK(igraph_vector_int_reserve(&edges, no_of_edges * 2)); ------------------ | | 752| 6.07k| do { \ | | 753| 6.07k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 6.07k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 6.07k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 6.07k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 6.07k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 131| | 132| 6.07k| IGRAPH_CHECK(igraph_es_all(&es, IGRAPH_EDGEORDER_FROM)); ------------------ | | 752| 6.07k| do { \ | | 753| 6.07k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 6.07k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 6.07k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 6.07k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 6.07k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 133| 6.07k| IGRAPH_FINALLY(igraph_es_destroy, &es); ------------------ | | 695| 6.07k| do { \ | | 696| 6.07k| /* the following branch makes the compiler check the compatibility of \ | | 697| 6.07k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 6.07k| * incorrect destructor function with the pointer */ \ | | 699| 6.07k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 6.07k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 6.07k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 134| 6.07k| IGRAPH_CHECK(igraph_eit_create(graph, es, &eit)); ------------------ | | 752| 6.07k| do { \ | | 753| 6.07k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 6.07k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 6.07k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 6.07k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 6.07k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 135| 6.07k| IGRAPH_FINALLY(igraph_eit_destroy, &eit); ------------------ | | 695| 6.07k| do { \ | | 696| 6.07k| /* the following branch makes the compiler check the compatibility of \ | | 697| 6.07k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 6.07k| * incorrect destructor function with the pointer */ \ | | 699| 6.07k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 6.07k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 6.07k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 136| | 137| 386k| for (actedge = -1; !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit)) { ------------------ | | 376| 386k|#define IGRAPH_EIT_END(eit) ((eit).pos >= (eit).end) ------------------ for (actedge = -1; !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit)) { ------------------ | | 364| 380k|#define IGRAPH_EIT_NEXT(eit) (++((eit).pos)) ------------------ | Branch (137:24): [True: 380k, False: 6.07k] ------------------ 138| 380k| edge = IGRAPH_EIT_GET(eit); ------------------ | | 410| 380k| (igraph_integer_t)((((eit).type == IGRAPH_EIT_RANGE) ? (eit).pos : \ | | ------------------ | | | Branch (410:25): [True: 0, False: 380k] | | ------------------ | | 411| 380k| VECTOR(*(eit).vec)[(eit).pos])) | | ------------------ | | | | 69| 380k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 139| 380k| from = IGRAPH_FROM(graph, edge); ------------------ | | 103| 380k|#define IGRAPH_FROM(graph,eid) ((igraph_integer_t)(VECTOR((graph)->from)[(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 380k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 140| 380k| to = IGRAPH_TO(graph, edge); ------------------ | | 116| 380k|#define IGRAPH_TO(graph,eid) ((igraph_integer_t)(VECTOR((graph)->to) [(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 380k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 141| | 142| 380k| if (loops && from == to) { ------------------ | Branch (142:13): [True: 380k, False: 0] | Branch (142:22): [True: 263k, False: 117k] ------------------ 143| | /* Loop edge to be removed */ 144| 263k| if (attr) { ------------------ | Branch (144:17): [True: 0, False: 263k] ------------------ 145| 0| VECTOR(mergeinto)[edge] = -1; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 146| 0| } 147| 263k| } else if (multiple && from == pfrom && to == pto) { ------------------ | Branch (147:20): [True: 117k, False: 0] | Branch (147:32): [True: 101k, False: 15.7k] | Branch (147:49): [True: 74.6k, False: 26.6k] ------------------ 148| | /* Multiple edge to be contracted */ 149| 74.6k| if (attr) { ------------------ | Branch (149:17): [True: 0, False: 74.6k] ------------------ 150| 0| VECTOR(mergeinto)[edge] = actedge; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 151| 0| } 152| 74.6k| } else { 153| | /* Edge to be kept */ 154| 42.4k| igraph_vector_int_push_back(&edges, from); /* reserved */ 155| 42.4k| igraph_vector_int_push_back(&edges, to); /* reserved */ 156| 42.4k| if (attr) { ------------------ | Branch (156:17): [True: 0, False: 42.4k] ------------------ 157| 0| actedge++; 158| 0| VECTOR(mergeinto)[edge] = actedge; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 159| 0| } 160| 42.4k| } 161| 380k| pfrom = from; pto = to; 162| 380k| } 163| | 164| 6.07k| igraph_eit_destroy(&eit); 165| 6.07k| igraph_es_destroy(&es); 166| 6.07k| IGRAPH_FINALLY_CLEAN(2); 167| | 168| 6.07k| IGRAPH_CHECK(igraph_create(&res, &edges, no_of_nodes, igraph_is_directed(graph))); ------------------ | | 752| 6.07k| do { \ | | 753| 6.07k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 6.07k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 6.07k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 6.07k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 6.07k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 169| | 170| 6.07k| igraph_vector_int_destroy(&edges); 171| 6.07k| IGRAPH_FINALLY_CLEAN(1); 172| | 173| 6.07k| IGRAPH_FINALLY(igraph_destroy, &res); ------------------ | | 695| 6.07k| do { \ | | 696| 6.07k| /* the following branch makes the compiler check the compatibility of \ | | 697| 6.07k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 6.07k| * incorrect destructor function with the pointer */ \ | | 699| 6.07k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 6.07k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 6.07k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 174| | 175| 6.07k| IGRAPH_I_ATTRIBUTE_DESTROY(&res); ------------------ | | 30| 6.07k| do {if ((graph)->attr) igraph_i_attribute_destroy(graph);} while(0) | | ------------------ | | | Branch (30:13): [True: 0, False: 6.07k] | | | Branch (30:70): [Folded - Ignored] | | ------------------ ------------------ 176| 6.07k| IGRAPH_I_ATTRIBUTE_COPY(&res, graph, /*graph=*/ true, /*vertex=*/ true, /*edge=*/ false); ------------------ | | 31| 6.07k|#define IGRAPH_I_ATTRIBUTE_COPY(to,from,ga,va,ea) do { \ | | 32| 6.07k| igraph_error_t igraph_i_ret2=IGRAPH_SUCCESS; \ | | 33| 6.07k| if ((from)->attr) { \ | | ------------------ | | | Branch (33:13): [True: 0, False: 6.07k] | | ------------------ | | 34| 0| IGRAPH_CHECK(igraph_i_ret2=igraph_i_attribute_copy((to),(from),(ga),(va),(ea))); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 35| 6.07k| } else { \ | | 36| 6.07k| (to)->attr = NULL; \ | | 37| 6.07k| } \ | | 38| 6.07k| if (igraph_i_ret2 != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (38:13): [True: 0, False: 6.07k] | | ------------------ | | 39| 0| IGRAPH_ERROR("", igraph_i_ret2); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 40| 0| } \ | | 41| 6.07k| } while(0) | | ------------------ | | | Branch (41:13): [Folded - Ignored] | | ------------------ ------------------ 177| | 178| 6.07k| if (attr) { ------------------ | Branch (178:9): [True: 0, False: 6.07k] ------------------ 179| 0| igraph_fixed_vectorlist_t vl; 180| 0| IGRAPH_CHECK(igraph_fixed_vectorlist_convert(&vl, &mergeinto, actedge + 1)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 181| 0| IGRAPH_FINALLY(igraph_fixed_vectorlist_destroy, &vl); ------------------ | | 695| 0| do { \ | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 0| * incorrect destructor function with the pointer */ \ | | 699| 0| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 0| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 182| | 183| 0| IGRAPH_CHECK(igraph_i_attribute_combine_edges(graph, &res, &vl.vecs, edge_comb)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 184| | 185| 0| igraph_fixed_vectorlist_destroy(&vl); 186| 0| igraph_vector_int_destroy(&mergeinto); 187| 0| IGRAPH_FINALLY_CLEAN(2); 188| 0| } 189| | 190| 6.07k| IGRAPH_FINALLY_CLEAN(1); 191| 6.07k| igraph_destroy(graph); 192| 6.07k| *graph = res; 193| | 194| | /* The cache must be set as the very last step, only after all functions that can 195| | * potentially return with an error have finished. */ 196| | 197| 6.07k| if (loops) { ------------------ | Branch (197:9): [True: 6.07k, False: 0] ------------------ 198| | /* Loop edges were removed so we know for sure that there aren't any 199| | * loop edges now */ 200| 6.07k| igraph_i_property_cache_set_bool(graph, IGRAPH_PROP_HAS_LOOP, false); 201| 6.07k| } 202| | 203| 6.07k| if (multiple) { ------------------ | Branch (203:9): [True: 6.07k, False: 0] ------------------ 204| | /* Multi-edges were removed so we know for sure that there aren't any 205| | * multi-edges now */ 206| 6.07k| igraph_i_property_cache_set_bool(graph, IGRAPH_PROP_HAS_MULTI, false); 207| 6.07k| } 208| | 209| 6.07k| return IGRAPH_SUCCESS; 210| 6.07k|} igraph_i_induced_subgraph_map: 345| 33.1k| igraph_bool_t map_is_prepared) { 346| | 347| 33.1k| if (impl == IGRAPH_SUBGRAPH_AUTO) { ------------------ | Branch (347:9): [True: 33.1k, False: 0] ------------------ 348| 33.1k| IGRAPH_CHECK(igraph_i_induced_subgraph_suggest_implementation(graph, vids, &impl)); ------------------ | | 752| 33.1k| do { \ | | 753| 33.1k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 33.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 33.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 33.1k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 33.1k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 349| 33.1k| } 350| | 351| 33.1k| switch (impl) { 352| 25.0k| case IGRAPH_SUBGRAPH_COPY_AND_DELETE: ------------------ | Branch (352:5): [True: 25.0k, False: 8.01k] ------------------ 353| 25.0k| return igraph_i_induced_subgraph_copy_and_delete(graph, res, vids, map, invmap); 354| | 355| 8.01k| case IGRAPH_SUBGRAPH_CREATE_FROM_SCRATCH: ------------------ | Branch (355:5): [True: 8.01k, False: 25.0k] ------------------ 356| 8.01k| return igraph_i_induced_subgraph_create_from_scratch(graph, res, vids, map, 357| 8.01k| invmap, /* map_is_prepared = */ map_is_prepared); 358| | 359| 0| default: ------------------ | Branch (359:5): [True: 0, False: 33.1k] ------------------ 360| 0| IGRAPH_ERROR("unknown subgraph implementation type", IGRAPH_EINVAL); ------------------ | | 493| 0| do { \ | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | 495| 0| return igraph_errno ; \ | | 496| 0| } while (0) | | ------------------ | | | Branch (496:14): [Folded - Ignored] | | ------------------ ------------------ 361| 33.1k| } 362| 33.1k|} igraph_induced_subgraph_map: 419| 33.1k| igraph_vector_int_t *invmap) { 420| 33.1k| return igraph_i_induced_subgraph_map(graph, res,vids, impl, map, invmap, /* map_is_prepared = */ false); 421| 33.1k|} subgraph.c:igraph_i_induced_subgraph_suggest_implementation: 319| 33.1k| igraph_subgraph_implementation_t *result) { 320| 33.1k| double ratio; 321| 33.1k| igraph_integer_t num_vs; 322| | 323| 33.1k| if (igraph_vs_is_all(&vids)) { ------------------ | Branch (323:9): [True: 0, False: 33.1k] ------------------ 324| 0| ratio = 1.0; 325| 33.1k| } else { 326| 33.1k| IGRAPH_CHECK(igraph_vs_size(graph, &vids, &num_vs)); ------------------ | | 752| 33.1k| do { \ | | 753| 33.1k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 33.1k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 33.1k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 33.1k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 33.1k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 327| 33.1k| ratio = (igraph_real_t) num_vs / igraph_vcount(graph); 328| 33.1k| } 329| | 330| | /* TODO: needs benchmarking; threshold was chosen totally arbitrarily */ 331| 33.1k| if (ratio > 0.5) { ------------------ | Branch (331:9): [True: 25.0k, False: 8.01k] ------------------ 332| 25.0k| *result = IGRAPH_SUBGRAPH_COPY_AND_DELETE; 333| 25.0k| } else { 334| 8.01k| *result = IGRAPH_SUBGRAPH_CREATE_FROM_SCRATCH; 335| 8.01k| } 336| | 337| 33.1k| return IGRAPH_SUCCESS; 338| 33.1k|} subgraph.c:igraph_i_induced_subgraph_copy_and_delete: 41| 25.0k| igraph_vector_int_t *map, igraph_vector_int_t *invmap) { 42| | 43| 25.0k| igraph_integer_t no_of_nodes = igraph_vcount(graph); 44| 25.0k| igraph_vector_int_t delete; 45| 25.0k| bool *remain; 46| 25.0k| igraph_integer_t i; 47| 25.0k| igraph_vit_t vit; 48| | 49| 25.0k| IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit)); ------------------ | | 752| 25.0k| do { \ | | 753| 25.0k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 25.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 25.0k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 50| 25.0k| IGRAPH_FINALLY(igraph_vit_destroy, &vit); ------------------ | | 695| 25.0k| do { \ | | 696| 25.0k| /* the following branch makes the compiler check the compatibility of \ | | 697| 25.0k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 25.0k| * incorrect destructor function with the pointer */ \ | | 699| 25.0k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 25.0k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 25.0k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 51| | 52| 25.0k| IGRAPH_VECTOR_INT_INIT_FINALLY(&delete, 0); ------------------ | | 124| 25.0k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 25.0k| do { \ | | | | 753| 25.0k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 25.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 25.0k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 25.0k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 25.0k| do { \ | | | | 696| 25.0k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 25.0k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 25.0k| * incorrect destructor function with the pointer */ \ | | | | 699| 25.0k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 25.0k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 25.0k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 53| | 54| 25.0k| remain = IGRAPH_CALLOC(no_of_nodes, bool); ------------------ | | 32| 25.0k|#define IGRAPH_CALLOC(n,t) (t*) calloc( (n) > 0 ? (size_t)((n)*sizeof(t)) : (size_t)1, 1 ) | | ------------------ | | | Branch (32:44): [True: 25.0k, False: 0] | | ------------------ ------------------ 55| 25.0k| IGRAPH_CHECK_OOM(remain, "Insufficient memory for taking subgraph."); ------------------ | | 807| 25.0k| do { \ | | 808| 25.0k| if (IGRAPH_UNLIKELY(!ptr)) { \ | | ------------------ | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | ------------------ | | ------------------ | | 809| 0| IGRAPH_ERROR(message, IGRAPH_ENOMEM); /* LCOV_EXCL_LINE */ \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 810| 0| } \ | | 811| 25.0k| } while (0) | | ------------------ | | | Branch (811:14): [Folded - Ignored] | | ------------------ ------------------ 56| 25.0k| IGRAPH_FINALLY(igraph_free, remain); ------------------ | | 695| 25.0k| do { \ | | 696| 25.0k| /* the following branch makes the compiler check the compatibility of \ | | 697| 25.0k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 25.0k| * incorrect destructor function with the pointer */ \ | | 699| 25.0k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 25.0k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 25.0k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 57| | 58| 25.0k| IGRAPH_CHECK(igraph_vector_int_reserve(&delete, no_of_nodes - IGRAPH_VIT_SIZE(vit))); ------------------ | | 752| 25.0k| do { \ | | 753| 25.0k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 25.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 25.0k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 59| | 60| 142k| for (IGRAPH_VIT_RESET(vit); !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit)) { ------------------ | | 205| 25.0k|#define IGRAPH_VIT_RESET(vit) ((vit).pos = (vit).start) ------------------ for (IGRAPH_VIT_RESET(vit); !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit)) { ------------------ | | 183| 142k|#define IGRAPH_VIT_END(vit) ((vit).pos >= (vit).end) ------------------ for (IGRAPH_VIT_RESET(vit); !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit)) { ------------------ | | 171| 117k|#define IGRAPH_VIT_NEXT(vit) (++((vit).pos)) ------------------ | Branch (60:33): [True: 117k, False: 25.0k] ------------------ 61| 117k| remain[ IGRAPH_VIT_GET(vit) ] = true; ------------------ | | 218| 117k| ((igraph_integer_t)(((vit).type == IGRAPH_VIT_RANGE) ? (vit).pos : \ | | ------------------ | | | Branch (218:25): [True: 0, False: 117k] | | ------------------ | | 219| 117k| VECTOR(*(vit).vec)[(vit).pos])) | | ------------------ | | | | 69| 117k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 62| 117k| } 63| | 64| 172k| for (i = 0; i < no_of_nodes; i++) { ------------------ | Branch (64:17): [True: 147k, False: 25.0k] ------------------ 65| 147k| IGRAPH_ALLOW_INTERRUPTION(); ------------------ | | 47| 147k| do { \ | | 48| 147k| if (igraph_i_interruption_handler) { \ | | ------------------ | | | Branch (48:13): [True: 0, False: 147k] | | ------------------ | | 49| 0| if (igraph_allow_interruption(NULL) != IGRAPH_SUCCESS) { \ | | ------------------ | | | Branch (49:17): [True: 0, False: 0] | | ------------------ | | 50| 0| return IGRAPH_INTERRUPTED; \ | | 51| 0| } \ | | 52| 0| } \ | | 53| 147k| } while (0) | | ------------------ | | | Branch (53:14): [Folded - Ignored] | | ------------------ ------------------ 66| | 67| 147k| if (! remain[i]) { ------------------ | Branch (67:13): [True: 30.0k, False: 117k] ------------------ 68| 30.0k| IGRAPH_CHECK(igraph_vector_int_push_back(&delete, i)); ------------------ | | 752| 30.0k| do { \ | | 753| 30.0k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 30.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 30.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 30.0k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 30.0k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 69| 30.0k| } 70| 147k| } 71| | 72| 25.0k| IGRAPH_FREE(remain); ------------------ | | 35| 25.0k|#define IGRAPH_FREE(p) (free( (void *)(p) ), (p) = NULL) ------------------ 73| 25.0k| IGRAPH_FINALLY_CLEAN(1); 74| | 75| | /* must set res->attr to 0 before calling igraph_copy */ 76| 25.0k| res->attr = 0; /* Why is this needed? TODO */ 77| 25.0k| IGRAPH_CHECK(igraph_copy(res, graph)); ------------------ | | 752| 25.0k| do { \ | | 753| 25.0k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 25.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 25.0k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 78| 25.0k| IGRAPH_FINALLY(igraph_destroy, res); ------------------ | | 695| 25.0k| do { \ | | 696| 25.0k| /* the following branch makes the compiler check the compatibility of \ | | 697| 25.0k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 25.0k| * incorrect destructor function with the pointer */ \ | | 699| 25.0k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 25.0k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 25.0k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 79| 25.0k| IGRAPH_CHECK(igraph_delete_vertices_idx(res, igraph_vss_vector(&delete), ------------------ | | 752| 25.0k| do { \ | | 753| 25.0k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 25.0k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 25.0k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 25.0k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 25.0k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 80| 25.0k| map, invmap)); 81| | 82| 25.0k| igraph_vector_int_destroy(&delete); 83| 25.0k| igraph_vit_destroy(&vit); 84| 25.0k| IGRAPH_FINALLY_CLEAN(3); 85| | 86| 25.0k| return IGRAPH_SUCCESS; 87| 25.0k|} subgraph.c:igraph_i_induced_subgraph_create_from_scratch: 102| 8.01k| igraph_bool_t map_is_prepared) { 103| | 104| 8.01k| igraph_bool_t directed = igraph_is_directed(graph); 105| 8.01k| igraph_integer_t no_of_nodes = igraph_vcount(graph); 106| 8.01k| igraph_integer_t no_of_new_nodes = 0; 107| 8.01k| igraph_integer_t i, j, n; 108| 8.01k| igraph_integer_t to; 109| 8.01k| igraph_integer_t eid; 110| 8.01k| igraph_vector_int_t vids_old2new, vids_new2old; 111| 8.01k| igraph_vector_int_t eids_new2old; 112| 8.01k| igraph_vector_int_t vids_vec; 113| 8.01k| igraph_vector_int_t nei_edges; 114| 8.01k| igraph_vector_int_t new_edges; 115| 8.01k| igraph_vit_t vit; 116| 8.01k| igraph_vector_int_t *my_vids_old2new = &vids_old2new, 117| 8.01k| *my_vids_new2old = &vids_new2old; 118| | 119| | /* The order of initialization is important here, they will be destroyed in the 120| | * opposite order */ 121| 8.01k| IGRAPH_VECTOR_INT_INIT_FINALLY(&eids_new2old, 0); ------------------ | | 124| 8.01k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 8.01k| do { \ | | | | 753| 8.01k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 8.01k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 8.01k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 8.01k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 8.01k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 8.01k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 8.01k| do { \ | | | | 696| 8.01k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 8.01k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 8.01k| * incorrect destructor function with the pointer */ \ | | | | 699| 8.01k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 8.01k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 8.01k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 122| 8.01k| if (invmap) { ------------------ | Branch (122:9): [True: 8.01k, False: 0] ------------------ 123| 8.01k| my_vids_new2old = invmap; 124| 8.01k| igraph_vector_int_clear(my_vids_new2old); 125| 8.01k| } else { 126| 0| IGRAPH_VECTOR_INT_INIT_FINALLY(&vids_new2old, 0); ------------------ | | 124| 0| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 0| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 0| do { \ | | | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 0| * incorrect destructor function with the pointer */ \ | | | | 699| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 0| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 127| 0| } 128| 8.01k| IGRAPH_VECTOR_INT_INIT_FINALLY(&new_edges, 0); ------------------ | | 124| 8.01k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 8.01k| do { \ | | | | 753| 8.01k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 8.01k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 8.01k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 8.01k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 8.01k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 8.01k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 8.01k| do { \ | | | | 696| 8.01k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 8.01k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 8.01k| * incorrect destructor function with the pointer */ \ | | | | 699| 8.01k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 8.01k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 8.01k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 129| 8.01k| IGRAPH_VECTOR_INT_INIT_FINALLY(&nei_edges, 0); ------------------ | | 124| 8.01k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 8.01k| do { \ | | | | 753| 8.01k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 8.01k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 8.01k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 8.01k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 8.01k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 8.01k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 8.01k| do { \ | | | | 696| 8.01k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 8.01k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 8.01k| * incorrect destructor function with the pointer */ \ | | | | 699| 8.01k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 8.01k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 8.01k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 130| 8.01k| if (map) { ------------------ | Branch (130:9): [True: 8.01k, False: 0] ------------------ 131| 8.01k| my_vids_old2new = map; 132| 8.01k| if (!map_is_prepared) { ------------------ | Branch (132:13): [True: 8.01k, False: 0] ------------------ 133| 8.01k| IGRAPH_CHECK(igraph_vector_int_resize(map, no_of_nodes)); ------------------ | | 752| 8.01k| do { \ | | 753| 8.01k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 8.01k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 8.01k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 8.01k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 8.01k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 134| 8.01k| igraph_vector_int_null(map); 135| 8.01k| } 136| 8.01k| } else { 137| 0| IGRAPH_VECTOR_INT_INIT_FINALLY(&vids_old2new, no_of_nodes); ------------------ | | 124| 0| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 0| do { \ | | | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 0| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 0| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 0| do { \ | | | | 696| 0| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 0| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 0| * incorrect destructor function with the pointer */ \ | | | | 699| 0| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 0| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 0| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 138| 0| } 139| 8.01k| IGRAPH_VECTOR_INT_INIT_FINALLY(&vids_vec, 0); ------------------ | | 124| 8.01k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 8.01k| do { \ | | | | 753| 8.01k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 8.01k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 8.01k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 8.01k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 8.01k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 8.01k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 8.01k| do { \ | | | | 696| 8.01k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 8.01k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 8.01k| * incorrect destructor function with the pointer */ \ | | | | 699| 8.01k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 8.01k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 8.01k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 140| | 141| 8.01k| IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit)); ------------------ | | 752| 8.01k| do { \ | | 753| 8.01k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 8.01k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 8.01k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 8.01k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 8.01k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 142| 8.01k| IGRAPH_FINALLY(igraph_vit_destroy, &vit); ------------------ | | 695| 8.01k| do { \ | | 696| 8.01k| /* the following branch makes the compiler check the compatibility of \ | | 697| 8.01k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 8.01k| * incorrect destructor function with the pointer */ \ | | 699| 8.01k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 8.01k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 8.01k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 143| | 144| | /* Calculate the mapping from the old node IDs to the new ones. The other 145| | * igraph_simplify implementation in igraph_i_simplify_copy_and_delete 146| | * ensures that the order of vertex IDs is kept during remapping (i.e. 147| | * if the old ID of vertex A is less than the old ID of vertex B, then 148| | * the same will also be true for the new IDs). To ensure compatibility 149| | * with the other implementation, we have to fetch the vertex IDs into 150| | * a vector first and then sort it. 151| | */ 152| 8.01k| IGRAPH_CHECK(igraph_vit_as_vector(&vit, &vids_vec)); ------------------ | | 752| 8.01k| do { \ | | 753| 8.01k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 8.01k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 8.01k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 8.01k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 8.01k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 153| 8.01k| igraph_vit_destroy(&vit); 154| 8.01k| IGRAPH_FINALLY_CLEAN(1); 155| | 156| 8.01k| igraph_vector_int_sort(&vids_vec); 157| 8.01k| n = igraph_vector_int_size(&vids_vec); 158| 34.4k| for (i = 0; i < n; i++) { ------------------ | Branch (158:17): [True: 26.4k, False: 8.01k] ------------------ 159| 26.4k| igraph_integer_t vid = VECTOR(vids_vec)[i]; ------------------ | | 69| 26.4k|#define VECTOR(v) ((v).stor_begin) ------------------ 160| 26.4k| if (VECTOR(*my_vids_old2new)[vid] == 0) { ------------------ | | 69| 26.4k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (160:13): [True: 26.4k, False: 0] ------------------ 161| 26.4k| IGRAPH_CHECK(igraph_vector_int_push_back(my_vids_new2old, vid)); ------------------ | | 752| 26.4k| do { \ | | 753| 26.4k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 26.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 26.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 26.4k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 26.4k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 162| 26.4k| no_of_new_nodes++; 163| 26.4k| VECTOR(*my_vids_old2new)[vid] = no_of_new_nodes; ------------------ | | 69| 26.4k|#define VECTOR(v) ((v).stor_begin) ------------------ 164| 26.4k| } 165| 26.4k| } 166| 8.01k| igraph_vector_int_destroy(&vids_vec); 167| 8.01k| IGRAPH_FINALLY_CLEAN(1); 168| | 169| | /* Create the new edge list */ 170| 34.4k| for (i = 0; i < no_of_new_nodes; i++) { ------------------ | Branch (170:17): [True: 26.4k, False: 8.01k] ------------------ 171| 26.4k| igraph_integer_t old_vid = VECTOR(*my_vids_new2old)[i]; ------------------ | | 69| 26.4k|#define VECTOR(v) ((v).stor_begin) ------------------ 172| 26.4k| igraph_integer_t new_vid = i; 173| 26.4k| igraph_bool_t skip_loop_edge; 174| | 175| 26.4k| IGRAPH_CHECK(igraph_incident(graph, &nei_edges, old_vid, IGRAPH_OUT)); ------------------ | | 752| 26.4k| do { \ | | 753| 26.4k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 26.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 26.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 26.4k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 26.4k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 176| 26.4k| n = igraph_vector_int_size(&nei_edges); 177| | 178| 26.4k| if (directed) { ------------------ | Branch (178:13): [True: 26.4k, False: 0] ------------------ 179| | /* directed graph; this is easier */ 180| 56.4k| for (j = 0; j < n; j++) { ------------------ | Branch (180:25): [True: 30.0k, False: 26.4k] ------------------ 181| 30.0k| eid = VECTOR(nei_edges)[j]; ------------------ | | 69| 30.0k|#define VECTOR(v) ((v).stor_begin) ------------------ 182| | 183| 30.0k| to = VECTOR(*my_vids_old2new)[ IGRAPH_TO(graph, eid) ]; ------------------ | | 69| 30.0k|#define VECTOR(v) ((v).stor_begin) ------------------ to = VECTOR(*my_vids_old2new)[ IGRAPH_TO(graph, eid) ]; ------------------ | | 116| 30.0k|#define IGRAPH_TO(graph,eid) ((igraph_integer_t)(VECTOR((graph)->to) [(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 30.0k|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 184| 30.0k| if (!to) { ------------------ | Branch (184:21): [True: 529, False: 29.4k] ------------------ 185| 529| continue; 186| 529| } 187| | 188| 29.4k| IGRAPH_CHECK(igraph_vector_int_push_back(&new_edges, new_vid)); ------------------ | | 752| 29.4k| do { \ | | 753| 29.4k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 29.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 29.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 29.4k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 29.4k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 189| 29.4k| IGRAPH_CHECK(igraph_vector_int_push_back(&new_edges, to - 1)); ------------------ | | 752| 29.4k| do { \ | | 753| 29.4k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 29.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 29.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 29.4k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 29.4k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 190| 29.4k| IGRAPH_CHECK(igraph_vector_int_push_back(&eids_new2old, eid)); ------------------ | | 752| 29.4k| do { \ | | 753| 29.4k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 29.4k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 29.4k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 29.4k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 29.4k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 191| 29.4k| } 192| 26.4k| } else { 193| | /* undirected graph. We need to be careful with loop edges as each 194| | * loop edge will appear twice. We use a boolean flag to skip every 195| | * second loop edge */ 196| 0| skip_loop_edge = 0; 197| 0| for (j = 0; j < n; j++) { ------------------ | Branch (197:25): [True: 0, False: 0] ------------------ 198| 0| eid = VECTOR(nei_edges)[j]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ 199| | 200| 0| if (IGRAPH_FROM(graph, eid) != old_vid) { ------------------ | | 103| 0|#define IGRAPH_FROM(graph,eid) ((igraph_integer_t)(VECTOR((graph)->from)[(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ | Branch (200:21): [True: 0, False: 0] ------------------ 201| | /* avoid processing edges twice */ 202| 0| continue; 203| 0| } 204| | 205| 0| to = VECTOR(*my_vids_old2new)[ IGRAPH_TO(graph, eid) ]; ------------------ | | 69| 0|#define VECTOR(v) ((v).stor_begin) ------------------ to = VECTOR(*my_vids_old2new)[ IGRAPH_TO(graph, eid) ]; ------------------ | | 116| 0|#define IGRAPH_TO(graph,eid) ((igraph_integer_t)(VECTOR((graph)->to) [(igraph_integer_t)(eid)])) | | ------------------ | | | | 69| 0|#define VECTOR(v) ((v).stor_begin) | | ------------------ ------------------ 206| 0| if (!to) { ------------------ | Branch (206:21): [True: 0, False: 0] ------------------ 207| 0| continue; 208| 0| } 209| 0| to -= 1; 210| | 211| 0| if (new_vid == to) { ------------------ | Branch (211:21): [True: 0, False: 0] ------------------ 212| | /* this is a loop edge; check whether we need to skip it */ 213| 0| skip_loop_edge = !skip_loop_edge; 214| 0| if (skip_loop_edge) { ------------------ | Branch (214:25): [True: 0, False: 0] ------------------ 215| 0| continue; 216| 0| } 217| 0| } 218| | 219| 0| IGRAPH_CHECK(igraph_vector_int_push_back(&new_edges, new_vid)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 220| 0| IGRAPH_CHECK(igraph_vector_int_push_back(&new_edges, to)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 221| 0| IGRAPH_CHECK(igraph_vector_int_push_back(&eids_new2old, eid)); ------------------ | | 752| 0| do { \ | | 753| 0| igraph_error_t igraph_i_ret = (expr); \ | | 754| 0| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 0| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 0| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 222| 0| } 223| 0| } 224| 26.4k| } 225| | 226| | /* Get rid of some vectors that are not needed anymore */ 227| 8.01k| if (!map) { ------------------ | Branch (227:9): [True: 0, False: 8.01k] ------------------ 228| 0| igraph_vector_int_destroy(&vids_old2new); 229| 0| IGRAPH_FINALLY_CLEAN(1); 230| 0| } 231| 8.01k| igraph_vector_int_destroy(&nei_edges); 232| 8.01k| IGRAPH_FINALLY_CLEAN(1); 233| | 234| | /* Create the new graph */ 235| 8.01k| IGRAPH_CHECK(igraph_create(res, &new_edges, no_of_new_nodes, directed)); ------------------ | | 752| 8.01k| do { \ | | 753| 8.01k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 8.01k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 8.01k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 8.01k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 8.01k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 236| 8.01k| IGRAPH_I_ATTRIBUTE_DESTROY(res); ------------------ | | 30| 8.01k| do {if ((graph)->attr) igraph_i_attribute_destroy(graph);} while(0) | | ------------------ | | | Branch (30:13): [True: 0, False: 8.01k] | | | Branch (30:70): [Folded - Ignored] | | ------------------ ------------------ 237| | 238| | /* Now we can also get rid of the new_edges vector */ 239| 8.01k| igraph_vector_int_destroy(&new_edges); 240| 8.01k| IGRAPH_FINALLY_CLEAN(1); 241| | 242| | /* Make sure that the newly created graph is destroyed if something happens from 243| | * now on */ 244| 8.01k| IGRAPH_FINALLY(igraph_destroy, res); ------------------ | | 695| 8.01k| do { \ | | 696| 8.01k| /* the following branch makes the compiler check the compatibility of \ | | 697| 8.01k| * func and ptr to detect cases when we are accidentally invoking an \ | | 698| 8.01k| * incorrect destructor function with the pointer */ \ | | 699| 8.01k| if (0) { func(ptr); } \ | | ------------------ | | | Branch (699:13): [Folded - Ignored] | | ------------------ | | 700| 8.01k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | 701| 8.01k| } while (0) | | ------------------ | | | Branch (701:14): [Folded - Ignored] | | ------------------ ------------------ 245| | 246| | /* Copy the graph attributes */ 247| 8.01k| IGRAPH_CHECK(igraph_i_attribute_copy(res, graph, ------------------ | | 752| 8.01k| do { \ | | 753| 8.01k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 8.01k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 8.01k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 8.01k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 8.01k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 248| 8.01k| /* ga = */ 1, /* va = */ 0, /* ea = */ 0)); 249| | 250| | /* Copy the vertex attributes */ 251| 8.01k| IGRAPH_CHECK(igraph_i_attribute_permute_vertices(graph, res, my_vids_new2old)); ------------------ | | 752| 8.01k| do { \ | | 753| 8.01k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 8.01k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 8.01k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 8.01k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 8.01k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 252| | 253| | /* Copy the edge attributes */ 254| 8.01k| IGRAPH_CHECK(igraph_i_attribute_permute_edges(graph, res, &eids_new2old)); ------------------ | | 752| 8.01k| do { \ | | 753| 8.01k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 8.01k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 8.01k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 8.01k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 8.01k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 255| | 256| | /* Get rid of the remaining stuff */ 257| 8.01k| if (!invmap) { ------------------ | Branch (257:9): [True: 0, False: 8.01k] ------------------ 258| 0| igraph_vector_int_destroy(my_vids_new2old); 259| 0| IGRAPH_FINALLY_CLEAN(1); 260| 0| } 261| 8.01k| igraph_vector_int_destroy(&eids_new2old); 262| 8.01k| IGRAPH_FINALLY_CLEAN(2); /* 1 + 1 since we don't need to destroy res */ 263| | 264| 8.01k| return IGRAPH_SUCCESS; 265| 8.01k|} igraph_is_dag: 152| 14.3k|igraph_error_t igraph_is_dag(const igraph_t* graph, igraph_bool_t *res) { 153| 14.3k| igraph_integer_t no_of_nodes = igraph_vcount(graph); 154| 14.3k| igraph_vector_int_t degrees; 155| 14.3k| igraph_vector_int_t neis; 156| 14.3k| igraph_dqueue_int_t sources; 157| | 158| 14.3k| if (!igraph_is_directed(graph)) { ------------------ | Branch (158:9): [True: 0, False: 14.3k] ------------------ 159| 0| *res = false; 160| 0| return IGRAPH_SUCCESS; 161| 0| } 162| | 163| 14.3k| IGRAPH_RETURN_IF_CACHED_BOOL(graph, IGRAPH_PROP_IS_DAG, res); ------------------ | | 85| 14.3k| do { \ | | 86| 14.3k| if (igraph_i_property_cache_has((graphptr), (prop))) { \ | | ------------------ | | | Branch (86:13): [True: 0, False: 14.3k] | | ------------------ | | 87| 0| *(resptr) = igraph_i_property_cache_get_bool((graphptr), (prop)); \ | | 88| 0| return IGRAPH_SUCCESS; \ | | 89| 0| } \ | | 90| 14.3k| } while (0) | | ------------------ | | | Branch (90:14): [Folded - Ignored] | | ------------------ ------------------ 164| | 165| 14.3k| IGRAPH_VECTOR_INT_INIT_FINALLY(°rees, no_of_nodes); ------------------ | | 124| 14.3k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 14.3k| do { \ | | | | 753| 14.3k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 14.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 14.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 14.3k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 14.3k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 14.3k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 14.3k| do { \ | | | | 696| 14.3k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 14.3k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 14.3k| * incorrect destructor function with the pointer */ \ | | | | 699| 14.3k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 14.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 14.3k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 166| 14.3k| IGRAPH_VECTOR_INT_INIT_FINALLY(&neis, 0); ------------------ | | 124| 14.3k| do { IGRAPH_CHECK(igraph_vector_int_init(v, size)); \ | | ------------------ | | | | 752| 14.3k| do { \ | | | | 753| 14.3k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 14.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 14.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 14.3k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 14.3k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 125| 14.3k| IGRAPH_FINALLY(igraph_vector_int_destroy, v); } while (0) | | ------------------ | | | | 695| 14.3k| do { \ | | | | 696| 14.3k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 14.3k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 14.3k| * incorrect destructor function with the pointer */ \ | | | | 699| 14.3k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 14.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 14.3k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (125:64): [Folded - Ignored] | | ------------------ ------------------ 167| 14.3k| IGRAPH_DQUEUE_INT_INIT_FINALLY(&sources, 0); ------------------ | | 66| 14.3k| do { IGRAPH_CHECK(igraph_dqueue_int_init(q, capacity)); \ | | ------------------ | | | | 752| 14.3k| do { \ | | | | 753| 14.3k| igraph_error_t igraph_i_ret = (expr); \ | | | | 754| 14.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | | | ------------------ | | | | | | 708| 14.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | | | ------------------ | | | | | | | Branch (708:32): [True: 0, False: 14.3k] | | | | | | ------------------ | | | | ------------------ | | | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | | | ------------------ | | | | | | 493| 0| do { \ | | | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | | | 495| 0| return igraph_errno ; \ | | | | | | 496| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (496:14): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | | | 756| 0| } \ | | | | 757| 14.3k| } while (0) | | | | ------------------ | | | | | Branch (757:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 67| 14.3k| IGRAPH_FINALLY(igraph_dqueue_int_destroy, q); } while (0) | | ------------------ | | | | 695| 14.3k| do { \ | | | | 696| 14.3k| /* the following branch makes the compiler check the compatibility of \ | | | | 697| 14.3k| * func and ptr to detect cases when we are accidentally invoking an \ | | | | 698| 14.3k| * incorrect destructor function with the pointer */ \ | | | | 699| 14.3k| if (0) { func(ptr); } \ | | | | ------------------ | | | | | Branch (699:13): [Folded - Ignored] | | | | ------------------ | | | | 700| 14.3k| IGRAPH_FINALLY_REAL((igraph_finally_func_t*)(func), (ptr)); \ | | | | 701| 14.3k| } while (0) | | | | ------------------ | | | | | Branch (701:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | | Branch (67:64): [Folded - Ignored] | | ------------------ ------------------ 168| | 169| 14.3k| IGRAPH_CHECK(igraph_degree(graph, °rees, igraph_vss_all(), IGRAPH_IN, /* loops */ true)); ------------------ | | 752| 14.3k| do { \ | | 753| 14.3k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 14.3k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 14.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 14.3k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 14.3k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 170| | 171| 14.3k| igraph_integer_t vertices_left = no_of_nodes; 172| | 173| | /* Do we have nodes with no incoming edges? */ 174| 372k| for (igraph_integer_t i = 0; i < no_of_nodes; i++) { ------------------ | Branch (174:34): [True: 358k, False: 14.3k] ------------------ 175| 358k| if (VECTOR(degrees)[i] == 0) { ------------------ | | 69| 358k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (175:13): [True: 65.7k, False: 292k] ------------------ 176| 65.7k| IGRAPH_CHECK(igraph_dqueue_int_push(&sources, i)); ------------------ | | 752| 65.7k| do { \ | | 753| 65.7k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 65.7k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 65.7k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 65.7k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 65.7k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 177| 65.7k| } 178| 358k| } 179| | 180| | /* Take all nodes with no incoming edges and remove them */ 181| 218k| while (!igraph_dqueue_int_empty(&sources)) { ------------------ | Branch (181:12): [True: 203k, False: 14.3k] ------------------ 182| 203k| igraph_integer_t node = igraph_dqueue_int_pop(&sources); 183| | /* Exclude the node from further source searches */ 184| 203k| VECTOR(degrees)[node] = -1; ------------------ | | 69| 203k|#define VECTOR(v) ((v).stor_begin) ------------------ 185| 203k| vertices_left--; 186| | /* Get the neighbors and decrease their degrees by one */ 187| 203k| IGRAPH_CHECK(igraph_neighbors(graph, &neis, node, IGRAPH_OUT)); ------------------ | | 752| 203k| do { \ | | 753| 203k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 203k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 203k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 203k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 203k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 188| 203k| igraph_integer_t n = igraph_vector_int_size(&neis); 189| 359k| for (igraph_integer_t i = 0; i < n; i++) { ------------------ | Branch (189:38): [True: 155k, False: 203k] ------------------ 190| 155k| igraph_integer_t nei = VECTOR(neis)[i]; ------------------ | | 69| 155k|#define VECTOR(v) ((v).stor_begin) ------------------ 191| 155k| if (nei == node) { ------------------ | Branch (191:17): [True: 0, False: 155k] ------------------ 192| | /* Found a self-loop, graph is not a DAG */ 193| 0| *res = false; 194| 0| goto finalize; 195| 0| } 196| 155k| VECTOR(degrees)[nei]--; ------------------ | | 69| 155k|#define VECTOR(v) ((v).stor_begin) ------------------ 197| 155k| if (VECTOR(degrees)[nei] == 0) { ------------------ | | 69| 155k|#define VECTOR(v) ((v).stor_begin) ------------------ | Branch (197:17): [True: 138k, False: 17.3k] ------------------ 198| 138k| IGRAPH_CHECK(igraph_dqueue_int_push(&sources, nei)); ------------------ | | 752| 138k| do { \ | | 753| 138k| igraph_error_t igraph_i_ret = (expr); \ | | 754| 138k| if (IGRAPH_UNLIKELY(igraph_i_ret != IGRAPH_SUCCESS)) {\ | | ------------------ | | | | 708| 138k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 138k] | | | | ------------------ | | ------------------ | | 755| 0| IGRAPH_ERROR("", igraph_i_ret); \ | | ------------------ | | | | 493| 0| do { \ | | | | 494| 0| igraph_error (reason, IGRAPH_FILE_BASENAME, __LINE__, igraph_errno) ; \ | | | | 495| 0| return igraph_errno ; \ | | | | 496| 0| } while (0) | | | | ------------------ | | | | | Branch (496:14): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 756| 0| } \ | | 757| 138k| } while (0) | | ------------------ | | | Branch (757:14): [Folded - Ignored] | | ------------------ ------------------ 199| 138k| } 200| 155k| } 201| 203k| } 202| | 203| 14.3k| IGRAPH_ASSERT(vertices_left >= 0); ------------------ | | 1107| 14.3k| do { \ | | 1108| 14.3k| if (IGRAPH_UNLIKELY(!(condition))) { \ | | ------------------ | | | | 708| 14.3k| #define IGRAPH_UNLIKELY(a) __builtin_expect((a), 0) | | | | ------------------ | | | | | Branch (708:32): [True: 0, False: 14.3k] | | | | ------------------ | | ------------------ | | 1109| 0| igraph_fatal("Assertion failed: " #condition, IGRAPH_FILE_BASENAME, __LINE__); \ | | 1110| 0| } \ | | 1111| 14.3k| } while (0) | | ------------------ | | | Branch (1111:14): [Folded - Ignored] | | ------------------ ------------------ 204| 14.3k| *res = (vertices_left == 0); 205| | 206| 14.3k|finalize: 207| 14.3k| igraph_vector_int_destroy(°rees); 208| 14.3k| igraph_vector_int_destroy(&neis); 209| 14.3k| igraph_dqueue_int_destroy(&sources); 210| 14.3k| IGRAPH_FINALLY_CLEAN(3); 211| | 212| 14.3k| igraph_i_property_cache_set_bool(graph, IGRAPH_PROP_IS_DAG, *res); 213| | 214| 14.3k| return IGRAPH_SUCCESS; 215| 14.3k|}