igraph_error_t igraph_vs_all(igraph_vs_t *vs);

Arguments: 

Returns: 

See also: 

This selector includes all vertices of a given graph in increasing vertex ID order.

Time complexity: O(1).

igraph_error_t igraph_vs_adj(igraph_vs_t *vs,
                  igraph_integer_t vid, igraph_neimode_t mode);

All neighboring vertices of a given vertex are selected by this selector. The mode argument controls the type of the neighboring vertices to be selected. The vertices are visited in increasing vertex ID order, as of igraph version 0.4.

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_error_t igraph_vs_nonadj(igraph_vs_t *vs, igraph_integer_t vid,
                     igraph_neimode_t mode);

All non-neighboring vertices of a given vertex. The mode argument controls the type of neighboring vertices not to select. Instead of selecting immediate neighbors of vid as is done by igraph_vs_adj(), the current function selects vertices that are not immediate neighbors of vid.

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

#include <igraph.h>

int main(void) {

    igraph_t g;
    igraph_vs_t vs;
    igraph_vit_t vit;
    igraph_integer_t size;

    /* empty graph, all vertices */
    igraph_empty(&g, 10, IGRAPH_DIRECTED);
    igraph_vs_nonadj(&vs, 0, IGRAPH_ALL);
    igraph_vs_size(&g, &vs, &size);
    printf("%" IGRAPH_PRId " ", size);
    igraph_vit_create(&g, vs, &vit);
    while (!IGRAPH_VIT_END(vit)) {
        printf("%" IGRAPH_PRId " ", IGRAPH_VIT_GET(vit));
        IGRAPH_VIT_NEXT(vit);
    }
    printf("\n");

    igraph_vit_destroy(&vit);
    igraph_vs_destroy(&vs);
    igraph_destroy(&g);

    /* full graph, no vertices */
    igraph_full(&g, 10, IGRAPH_UNDIRECTED, IGRAPH_LOOPS);
    igraph_vs_nonadj(&vs, 0, IGRAPH_ALL);
    igraph_vit_create(&g, vs, &vit);
    while (!IGRAPH_VIT_END(vit)) {
        printf("%" IGRAPH_PRId " ", IGRAPH_VIT_GET(vit));
        IGRAPH_VIT_NEXT(vit);
    }
    printf("\n");

    igraph_vit_destroy(&vit);
    igraph_vs_destroy(&vs);
    igraph_destroy(&g);


    return 0;
}

igraph_error_t igraph_vs_none(igraph_vs_t *vs);

Creates an empty vertex selector.

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_error_t igraph_vs_1(igraph_vs_t *vs, igraph_integer_t vid);

This vertex selector selects a single vertex.

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_error_t igraph_vs_vector(igraph_vs_t *vs,
                     const igraph_vector_int_t *v);

This function makes it possible to handle an igraph_vector_int_t temporarily as a vertex selector. The vertex selector should be thought of as a view into the vector. If you make changes to the vector that also affects the vertex selector. Destroying the vertex selector does not destroy the vector. Do not destroy the vector before destroying the vertex selector, or you might get strange behavior. Since selectors are not tied to any specific graph, this function does not check whether the vertex IDs in the vector are valid.

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

#include <igraph.h>

int main(void) {

    igraph_t g;
    igraph_vector_int_t v = IGRAPH_VECTOR_NULL;
    igraph_integer_t edges[] = { 0, 1, 1, 2, 2, 2, 2, 3, 2, 4, 3, 4 };
    igraph_vector_int_t v2;
    igraph_integer_t i;
    igraph_vit_t vit;
    igraph_vs_t vs;
    igraph_integer_t size;

    igraph_vector_int_view(&v, edges, sizeof(edges) / sizeof(igraph_integer_t));
    igraph_create(&g, &v, 0, IGRAPH_DIRECTED);

    /* Create iterator based on a vector (view) */
    igraph_vector_int_init(&v2, 6);
    VECTOR(v2)[0] = 0;
    VECTOR(v2)[1] = 2;
    VECTOR(v2)[2] = 4;
    VECTOR(v2)[3] = 0;
    VECTOR(v2)[4] = 2;
    VECTOR(v2)[5] = 4;

    igraph_vit_create(&g, igraph_vss_vector(&v2), &vit);

    i = 0;
    while (!IGRAPH_VIT_END(vit)) {
        if (IGRAPH_VIT_GET(vit) != VECTOR(v2)[i]) {
            return 1;
        }
        IGRAPH_VIT_NEXT(vit);
        i++;
    }
    if (i != igraph_vector_int_size(&v2)) {
        return 2;
    }

    igraph_vit_destroy(&vit);
    igraph_vector_int_destroy(&v2);

    /* Create small vector iterator */

    igraph_vs_vector_small(&vs, 0, 2, 4, 0, 2, 4, 2, -1);
    igraph_vit_create(&g, vs, &vit);
    igraph_vs_size(&g, &vs, &size);
    printf("%" IGRAPH_PRId " ", size);
    for (; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit)) {
        printf("%" IGRAPH_PRId " ", IGRAPH_VIT_GET(vit));
    }
    printf("\n");

    igraph_vit_destroy(&vit);
    igraph_vs_destroy(&vs);

    /* Clean up */

    igraph_destroy(&g);

    return 0;
}

igraph_error_t igraph_vs_vector_small(igraph_vs_t *vs, ...);

This function can be used to create a vertex selector with a few of vertices. Do not forget to include a -1 after the last vertex ID. The behavior of the function is undefined if you don't use a -1 properly.

Note that the vertex IDs supplied will be parsed as value of type int so you cannot supply arbitrarily large (too large for int) vertex IDs here.

Arguments: 

Returns: 

See also: 

Time complexity: O(n), the number of vertex IDs supplied.

igraph_error_t igraph_vs_vector_copy(igraph_vs_t *vs, const igraph_vector_int_t *v);

This function makes it possible to handle an igraph_vector_int_t permanently as a vertex selector. The vertex selector creates a copy of the original vector, so the vector can safely be destroyed after creating the vertex selector. Changing the original vector will not affect the vertex selector. The vertex selector is responsible for deleting the copy made by itself. Since selectors are not tied to any specific graph, this function does not check whether the vertex IDs in the vector are valid.

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_error_t igraph_vs_range(igraph_vs_t *vs, igraph_integer_t start, igraph_integer_t end);

Creates a vertex selector containing all vertices with vertex ID equal to or bigger than from and smaller than to. Note that the interval is closed from the left and open from the right, following C conventions.

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

#include <igraph.h>

int main(void) {

    igraph_vs_t vs;
    igraph_vit_t vit;
    igraph_t g;
    igraph_integer_t size;

    igraph_ring(&g, 10, IGRAPH_UNDIRECTED, 0, 1);
    igraph_vs_range(&vs, 0, 10);
    igraph_vit_create(&g, vs, &vit);
    igraph_vs_size(&g, &vs, &size);
    printf("%" IGRAPH_PRId "", size);

    while (!IGRAPH_VIT_END(vit)) {
        printf(" %" IGRAPH_PRId "", IGRAPH_VIT_GET(vit));
        IGRAPH_VIT_NEXT(vit);
    }
    printf("\n");

    igraph_vit_destroy(&vit);
    igraph_vs_destroy(&vs);
    igraph_destroy(&g);

    return 0;
}

igraph_error_t igraph_vs_copy(igraph_vs_t* dest, const igraph_vs_t* src);

Arguments: 

void igraph_vs_destroy(igraph_vs_t *vs);

This function should be called for all vertex selectors when they are not needed. The memory allocated for the vertex selector will be deallocated. Do not call this function on vertex selectors created with the immediate versions of the vertex selector constructors (starting with igraph_vss).

Arguments: 

Time complexity: operating system dependent, usually O(1).

igraph_bool_t igraph_vs_is_all(const igraph_vs_t *vs);

This function checks whether the vertex selector object was created by igraph_vs_all() or igraph_vss_all(). Note that the vertex selector might contain all vertices in a given graph but if it wasn't created by the two constructors mentioned here the return value will be false.

Arguments: 

Returns: 

Time complexity: O(1).

igraph_error_t igraph_vs_size(const igraph_t *graph, const igraph_vs_t *vs,
                   igraph_integer_t *result);

The size of the vertex selector is the number of vertices it will yield when it is iterated over.

Arguments: 

igraph_vs_t igraph_vss_all(void);

Immediate vertex selector for all vertices in a graph. It can be used conveniently when some vertex property (e.g. betweenness, degree, etc.) should be calculated for all vertices.

Returns: 

See also: 

Time complexity: O(1).

igraph_vs_t igraph_vss_none(void);

The immediate version of the empty vertex selector.

Returns: 

See also: 

Time complexity: O(1).

igraph_vs_t igraph_vss_1(igraph_integer_t vid);

The immediate version of the single-vertex selector.

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_vs_t igraph_vss_vector(const igraph_vector_int_t *v);

This is the immediate version of igraph_vs_vector.

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_vs_t igraph_vss_range(igraph_integer_t start, igraph_integer_t end);

The immediate version of igraph_vs_range().

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_error_t igraph_vit_create(const igraph_t *graph, igraph_vs_t vs, igraph_vit_t *vit);

This function instantiates a vertex selector object with a given graph. This is the step when the actual vertex IDs are created from the logical notion of the vertex selector based on the graph. E.g. a vertex selector created with igraph_vs_all() contains knowledge that all vertices are included in a (yet indefinite) graph. When instantiating it a vertex iterator object is created, this contains the actual vertex IDs in the graph supplied as a parameter.

The same vertex selector object can be used to instantiate any number vertex iterators.

Arguments: 

Returns: 

See also: 

Time complexity: it depends on the vertex selector type. O(1) for vertex selectors created with igraph_vs_all(), igraph_vs_none(), igraph_vs_1, igraph_vs_vector, igraph_vs_range(), igraph_vs_vector(), igraph_vs_vector_small(). O(d) for igraph_vs_adj(), d is the number of vertex IDs to be included in the iterator. O(|V|) for igraph_vs_nonadj(), |V| is the number of vertices in the graph.

void igraph_vit_destroy(const igraph_vit_t *vit);

Deallocates memory allocated for a vertex iterator.

Arguments: 

See also: 

Time complexity: operating system dependent, usually O(1).

After creating an iterator with igraph_vit_create(), it points to the first vertex in the vertex determined by the vertex selector (if there is any). The IGRAPH_VIT_NEXT() macro steps to the next vertex, IGRAPH_VIT_END() checks whether there are more vertices to visit, IGRAPH_VIT_SIZE() gives the total size of the vertices visited so far and to be visited. IGRAPH_VIT_RESET() resets the iterator, it will point to the first vertex again. Finally IGRAPH_VIT_GET() gives the current vertex pointed to by the iterator (call this only if IGRAPH_VIT_END() is false).

Here is an example on how to step over the neighbors of vertex 0:

igraph_vs_t vs;
igraph_vit_t vit;
...
igraph_vs_adj(&vs, 0, IGRAPH_ALL);
igraph_vit_create(&graph, vs, &vit);
while (!IGRAPH_VIT_END(vit)) {
  printf(" %" IGRAPH_PRId, IGRAPH_VIT_GET(vit));
  IGRAPH_VIT_NEXT(vit);
}
printf("\n");
...
igraph_vit_destroy(&vit);
igraph_vs_destroy(&vs);

#define IGRAPH_VIT_NEXT(vit)

Steps the iterator to the next vertex. Only call this function if IGRAPH_VIT_END() returns false.

Arguments: 

Time complexity: O(1).

#define IGRAPH_VIT_END(vit)

Checks whether there are more vertices to step to.

Arguments: 

Returns: 

Time complexity: O(1).

#define IGRAPH_VIT_SIZE(vit)

Gives the number of vertices in a vertex iterator.

Arguments: 

Returns: 

Time complexity: O(1).

#define IGRAPH_VIT_RESET(vit)

Resets a vertex iterator. After calling this macro the iterator will point to the first vertex.

Arguments: 

Time complexity: O(1).

#define IGRAPH_VIT_GET(vit)

Gives the vertex ID of the current vertex pointed to by the iterator.

Arguments: 

Returns: 

Time complexity: O(1).

igraph_error_t igraph_es_all(igraph_es_t *es,
                  igraph_edgeorder_type_t order);

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_error_t igraph_es_incident(igraph_es_t *es,
                       igraph_integer_t vid, igraph_neimode_t mode);

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_error_t igraph_es_none(igraph_es_t *es);

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_error_t igraph_es_1(igraph_es_t *es, igraph_integer_t eid);

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_error_t igraph_es_all_between(
    igraph_es_t *es, igraph_integer_t from, igraph_integer_t to,
    igraph_bool_t directed
);

This function takes a pair of vertices and creates a selector that matches all edges between those vertices.

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_error_t igraph_es_vector(igraph_es_t *es, const igraph_vector_int_t *v);

Creates an edge selector which serves as a view into a vector containing edge IDs. Do not destroy the vector before destroying the edge selector. Since selectors are not tied to any specific graph, this function does not check whether the edge IDs in the vector are valid.

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_error_t igraph_es_range(igraph_es_t *es, igraph_integer_t start, igraph_integer_t end);

Creates an edge selector containing all edges with edge ID equal to or bigger than from and smaller than to. Note that the interval is closed from the left and open from the right, following C conventions.

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_error_t igraph_es_pairs(igraph_es_t *es, const igraph_vector_int_t *v,
                    igraph_bool_t directed);

The edges between the given pairs of vertices will be included in the edge selection. The vertex pairs must be defined in the vector v, the first element of the vector is the first vertex of the first edge to be selected, the second element is the second vertex of the first edge, the third element is the first vertex of the second edge and so on.

Arguments: 

Returns: 

See also: 

Time complexity: O(n), the number of edges being selected.

#include <igraph.h>

int main(void) {

    igraph_t g;
    igraph_integer_t i;
    igraph_integer_t size;

    /* DIRECTED */

    igraph_star(&g, 10, IGRAPH_STAR_OUT, 0);

    for (i = 0; i < 100; i++) {
        igraph_es_t es;
        igraph_eit_t it;
        igraph_es_pairs_small(&es, IGRAPH_DIRECTED,
                              0, 1, 0, 2, 0, 5, 0, 2, 0, 3, 0, 4, 0, 7, 0, 9, -1);
        igraph_eit_create(&g, es, &it);
        igraph_es_size(&g, &es, &size);
        IGRAPH_EIT_RESET(it);
        while (!IGRAPH_EIT_END(it)) {
            (void) IGRAPH_EIT_GET(it);
            IGRAPH_EIT_NEXT(it);
            size--;
        }
        if (size != 0) {
            return 1;
        }
        igraph_eit_destroy(&it);
        igraph_es_destroy(&es);
    }

    igraph_destroy(&g);

    /* UNDIRECTED */

    igraph_star(&g, 10, IGRAPH_STAR_UNDIRECTED, 0);

    for (i = 0; i < 100; i++) {
        igraph_es_t es;
        igraph_eit_t it;
        igraph_es_pairs_small(&es, IGRAPH_DIRECTED,
                              0, 1, 2, 0, 5, 0, 0, 2, 3, 0, 0, 4, 7, 0, 0, 9, -1);
        igraph_eit_create(&g, es, &it);
        IGRAPH_EIT_RESET(it);
        while (!IGRAPH_EIT_END(it)) {
            (void) IGRAPH_EIT_GET(it);
            IGRAPH_EIT_NEXT(it);
        }
        igraph_eit_destroy(&it);
        igraph_es_destroy(&es);
    }

    igraph_destroy(&g);

    return 0;
}

igraph_error_t igraph_es_pairs_small(igraph_es_t *es, igraph_bool_t directed, int first, ...);

The edges between the given pairs of vertices will be included in the edge selection. The vertex pairs must be given as the arguments of the function call, the third argument is the first vertex of the first edge, the fourth argument is the second vertex of the first edge, the fifth is the first vertex of the second edge and so on. The last element of the argument list must be -1 to denote the end of the argument list.

Note that the vertex IDs supplied will be parsed as int's so you cannot supply arbitrarily large (too large for int) vertex IDs here.

Arguments: 

Returns: 

See also: 

Time complexity: O(n), the number of edges being selected.

igraph_error_t igraph_es_path(igraph_es_t *es, const igraph_vector_int_t *v,
                   igraph_bool_t directed);

This function takes a vector of vertices and creates a selector of edges between those vertices. Vector {0, 3, 4, 7} will select edges (0 -> 3), (3 -> 4), (4 -> 7). If these edges don't exist then trying to create an iterator using this selector will fail.

Arguments: 

Returns: 

See also: 

Time complexity: O(n), the number of vertices.

igraph_error_t igraph_es_vector_copy(igraph_es_t *es, const igraph_vector_int_t *v);

This function makes it possible to handle an igraph_vector_int_t permanently as an edge selector. The edge selector creates a copy of the original vector, so the vector can safely be destroyed after creating the edge selector. Changing the original vector will not affect the edge selector. The edge selector is responsible for deleting the copy made by itself. Since selectors are not tied to any specific graph, this function does not check whether the edge IDs in the vector are valid.

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_es_t igraph_ess_all(igraph_edgeorder_type_t order);

The immediate version of the all-edges selector.

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_es_t igraph_ess_none(void);

Immediate version of the empty edge selector.

Returns: 

See also: 

Time complexity: O(1).

igraph_es_t igraph_ess_1(igraph_integer_t eid);

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_es_t igraph_ess_vector(const igraph_vector_int_t *v);

This is the immediate version of the vector of edge IDs edge selector.

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_es_t igraph_ess_range(igraph_integer_t start, igraph_integer_t end);

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_error_t igraph_es_as_vector(const igraph_t *graph, igraph_es_t es,
                        igraph_vector_int_t *v);

Call this function on an edge selector to transform it into a vector. This is only implemented for sequence and vector selectors. If the edges do not exist in the graph, this will result in an error.

Arguments: 

Time complexity: O(n), the number of edges in the selector.

igraph_error_t igraph_es_copy(igraph_es_t* dest, const igraph_es_t* src);

Arguments: 

See also: 

void igraph_es_destroy(igraph_es_t *es);

Call this function on an edge selector when it is not needed any more. Do not call this function on edge selectors created by immediate constructors, those don't need to be destroyed.

Arguments: 

Time complexity: operating system dependent, usually O(1).

igraph_bool_t igraph_es_is_all(const igraph_es_t *es);

Arguments: 

Returns: 

Time complexity: O(1).

igraph_error_t igraph_es_size(const igraph_t *graph, const igraph_es_t *es,
                   igraph_integer_t *result);

The size of the edge selector is the number of edges it will yield when it is iterated over.

Arguments: 

igraph_error_t igraph_eit_create(const igraph_t *graph, igraph_es_t es, igraph_eit_t *eit);

This function creates an edge iterator based on an edge selector and a graph.

The same edge selector can be used to create many edge iterators, also for different graphs.

Arguments: 

Returns: 

See also: 

Time complexity: depends on the type of the edge selector. For edge selectors created by igraph_es_all(), igraph_es_none(), igraph_es_1(), igraph_es_vector(), igraph_es_range() it is O(1). For igraph_es_incident() it is O(d) where d is the number of incident edges of the vertex.

void igraph_eit_destroy(const igraph_eit_t *eit);

Arguments: 

See also: 

Time complexity: operating system dependent, usually O(1).

Just like for vertex iterators, macros are provided for stepping over a sequence of edges: IGRAPH_EIT_NEXT() goes to the next edge, IGRAPH_EIT_END() checks whether there are more edges to visit, IGRAPH_EIT_SIZE() gives the number of edges in the edge sequence, IGRAPH_EIT_RESET() resets the iterator to the first edge and IGRAPH_EIT_GET() returns the id of the current edge.

#define IGRAPH_EIT_NEXT(eit)

Steps the iterator to the next edge. Call this function only if IGRAPH_EIT_END() returns false.

Arguments: 

Time complexity: O(1).

#define IGRAPH_EIT_END(eit)

Checks whether there are more edges to step to.

Arguments: 

Returns: 

Time complexity: O(1).

#define IGRAPH_EIT_SIZE(eit)

Gives the number of edges in an edge iterator.

Arguments: 

Returns: 

Time complexity: O(1).

#define IGRAPH_EIT_RESET(eit)

Resets an edge iterator. After calling this macro the iterator will point to the first edge.

Arguments: 

Time complexity: O(1).

#define IGRAPH_EIT_GET(eit)

Gives the edge ID of the current edge pointed to by an iterator.

Arguments: 

Returns: 

Time complexity: O(1).

igraph_error_t igraph_es_seq(igraph_es_t *es, igraph_integer_t from, igraph_integer_t to);

All edge IDs between from and to (inclusive) will be included in the edge selection.

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_es_t igraph_ess_seq(igraph_integer_t from, igraph_integer_t to);

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_error_t igraph_vs_seq(igraph_vs_t *vs, igraph_integer_t from, igraph_integer_t to);

Creates a vertex selector containing all vertices with vertex ID equal to or bigger than from and equal to or smaller than to. Note that both endpoints are inclusive, contrary to C conventions.

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

#include <igraph.h>

int main(void) {

    igraph_vs_t vs;
    igraph_vit_t vit;
    igraph_t g;
    igraph_integer_t size;

    igraph_ring(&g, 10, IGRAPH_UNDIRECTED, 0, 1);
    igraph_vs_range(&vs, 0, 10);
    igraph_vit_create(&g, vs, &vit);
    igraph_vs_size(&g, &vs, &size);
    printf("%" IGRAPH_PRId "", size);

    while (!IGRAPH_VIT_END(vit)) {
        printf(" %" IGRAPH_PRId "", IGRAPH_VIT_GET(vit));
        IGRAPH_VIT_NEXT(vit);
    }
    printf("\n");

    igraph_vit_destroy(&vit);
    igraph_vs_destroy(&vs);
    igraph_destroy(&g);

    return 0;
}

igraph_vs_t igraph_vss_seq(igraph_integer_t from, igraph_integer_t to);

The immediate version of igraph_vs_seq().

Arguments: 

Returns: 

See also: 

Time complexity: O(1).