Chapter 7. Data structure library: vector, matrix, other data types

2.2.1.igraph_vector_init — Initializes a vector object (constructor).

2.2.2.igraph_vector_init_array — Initializes a vector from an ordinary C array (constructor).

2.2.3.igraph_vector_init_copy — Initializes a vector from another vector object (constructor).

2.2.4.igraph_vector_init_range — Initializes a vector with a range.

2.2.5.igraph_vector_destroy — Destroys a vector object.

igraph_error_t igraph_vector_init(igraph_vector_t *v, igraph_integer_t size);

Every vector needs to be initialized before it can be used, andthere are a number of initialization functions or otherwise calledconstructors. This function constructs a vector of the given size andinitializes each entry to 0. Note thatigraph_vector_null() can beused to set each element of a vector to zero. However, if you want avector of zeros, it is much faster to use this function than to create avector and then invokeigraph_vector_null().

Every vector object initialized by this function should bedestroyed (ie. the memory allocated for it should be freed) when itis not needed anymore, theigraph_vector_destroy() function isresponsible for this.

Arguments: 

Returns: 

Time complexity: operating system dependent, the amount of“time” required to allocateO(n) elements,n is the number of elements.

igraph_error_t igraph_vector_init_array(        igraph_vector_t *v, const igraph_real_t *data, igraph_integer_t length);

Arguments: 

Returns: 

Time complexity: operating system specific, usuallyO(length).

igraph_error_t igraph_vector_init_copy(    igraph_vector_t *to, const igraph_vector_t *from);

The contents of the existing vector object will be copied tothe new one.

Arguments: 

Returns: 

Time complexity: operating system dependent, usuallyO(n),n is the size of the vector.

igraph_error_t igraph_vector_init_range(igraph_vector_t *v, igraph_real_t start, igraph_real_t end);

The vector will contain the numbersstart,start+1, ...,end-1. Notethat the range is closed from the left and open from the right, according toC conventions.

Arguments: 

Returns: 

Time complexity: O(n), the number of elements in the vector.

void igraph_vector_destroy(igraph_vector_t *v);

All vectors initialized byigraph_vector_init() should be properlydestroyed by this function. A destroyed vector needs to bereinitialized byigraph_vector_init(),igraph_vector_init_array() oranother constructor.

Arguments: 

Time complexity: operating system dependent.

2.3.1.igraph_vector_null — Sets each element in the vector to zero.

2.3.2.igraph_vector_fill — Fill a vector with a constant element.

2.3.3.igraph_vector_range — Updates a vector to store a range.

void igraph_vector_null(igraph_vector_t *v);

Note thatigraph_vector_init() sets the elements to zero as well, soit makes no sense to call this function on a just initializedvector. Thus if you want to construct a vector of zeros, then you shoulduseigraph_vector_init().

Arguments: 

Time complexity: O(n), the size ofthe vector.

void igraph_vector_fill(igraph_vector_t *v, igraph_real_t e);

Sets each element of the vector to the supplied constant.

Arguments: 

Time complexity: O(n), the size of the vector.

igraph_error_t igraph_vector_range(igraph_vector_t *v, igraph_real_t start, igraph_real_t end);

Sets the elements of the vector to contain the numbersstart,start+1,...,end-1. Note that the range is closed from the left and open from theright, according to C conventions. The vector will be resized to fit the range.

Arguments: 

Returns: 

Time complexity: O(n), the number of elements in the vector.

2.4.1.VECTOR — Accessing an element of a vector.

2.4.2.igraph_vector_get — Access an element of a vector.

2.4.3.igraph_vector_get_ptr — Get the address of an element of a vector.

2.4.4.igraph_vector_set — Assignment to an element of a vector.

2.4.5.igraph_vector_tail — Returns the last element in a vector.

#define VECTOR(v)

Usage:

 VECTOR(v)[0]

to access the first element of the vector, you can also use this inassignments, like:

 VECTOR(v)[10] = 5;

Note that there are no range checks right now.

Arguments: 

Time complexity: O(1).

igraph_real_t igraph_vector_get(const igraph_vector_t *v, igraph_integer_t pos);

Unless you need a function, consider using theVECTORmacro instead for better performance.

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_real_t* igraph_vector_get_ptr(const igraph_vector_t *v, igraph_integer_t pos);

Unless you need a function, consider using theVECTORmacro instead for better performance.

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

void igraph_vector_set(igraph_vector_t *v, igraph_integer_t pos, igraph_real_t value);

Unless you need a function, consider using theVECTORmacro instead for better performance.

Arguments: 

See also: 

igraph_real_t igraph_vector_tail(const igraph_vector_t *v);

It is an error to call this function on an empty vector, the resultis undefined.

Arguments: 

Returns: 

Time complexity: O(1).

2.5.1.igraph_vector_view — Handle a regular C array as aigraph_vector_t.

const igraph_vector_t* igraph_vector_view(const igraph_vector_t *v,        const igraph_real_t *data, igraph_integer_t length);

This is a specialigraph_vector_t constructor. It allows tohandle a regular C array as aigraph_vector_t temporarily.Be sure that youdon't ever call the destructor (igraph_vector_destroy()) on objects created by this constructor.

Arguments: 

Returns: 

Time complexity: O(1)

2.6.1.igraph_vector_copy_to — Copies the contents of a vector to a C array.

2.6.2.igraph_vector_update — Update a vector from another one.

2.6.3.igraph_vector_append — Append a vector to another one.

2.6.4.igraph_vector_swap — Swap all elements of two vectors.

void igraph_vector_copy_to(const igraph_vector_t *v, igraph_real_t *to);

The C array should have sufficient length.

Arguments: 

Time complexity: O(n),n is the size of the vector.

igraph_error_t igraph_vector_update(igraph_vector_t *to,                                    const igraph_vector_t *from);

After this operation the contents ofto will be exactly the sameas that offrom. The vectorto will be resized if it was originallyshorter or longer thanfrom.

Arguments: 

Returns: 

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

igraph_error_t igraph_vector_append(igraph_vector_t *to,                                    const igraph_vector_t *from);

The target vector will be resized (except whenfrom is empty).

Arguments: 

Returns: 

Time complexity: O(n), the number of elements in the new vector.

igraph_error_t igraph_vector_swap(igraph_vector_t *v1, igraph_vector_t *v2);

Arguments: 

Returns: 

Time complexity: O(1).

2.7.1.igraph_vector_swap_elements — Swap two elements in a vector.

2.7.2.igraph_vector_reverse — Reverse the elements of a vector.

2.7.3.igraph_vector_reverse_section — Reverse the elements in a section of a vector.

2.7.4.igraph_vector_rotate_left — Rotates the elements of a vector to the left.

2.7.5.igraph_vector_shuffle — Shuffles a vector in-place using the Fisher-Yates method.

2.7.6.igraph_vector_permute — Permutes the elements of a vector in place according to an index vector.

igraph_error_t igraph_vector_swap_elements(igraph_vector_t *v,        igraph_integer_t i, igraph_integer_t j);

Note that currently no range checking is performed.

Arguments: 

Returns: 

Time complexity: O(1).

igraph_error_t igraph_vector_reverse(igraph_vector_t *v);

The first element will be last, the last element will befirst, etc.

Arguments: 

Returns: 

See also: 

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

void igraph_vector_reverse_section(igraph_vector_t *v, igraph_integer_t from, igraph_integer_t to);

Arguments: 

See also: 

Time complexity: O(to - from), the number of elements to reverse.

void igraph_vector_rotate_left(igraph_vector_t *v, igraph_integer_t n);

Rotates the elements of a vector to the left by the given number of steps.Element indexn will have index 0 after the rotation.For example, rotating(0, 1, 2, 3, 4, 5) by 2 yields(2, 3, 4, 5, 0, 1).

Arguments: 

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

igraph_error_t igraph_vector_shuffle(igraph_vector_t *v);

The Fisher-Yates shuffle ensures that every permutation isequally probable when using a proper randomness source. Of coursethis does not apply to pseudo-random generators as the cycle ofthese generators is less than the number of possible permutationsof the vector if the vector is long enough.

Arguments: 

Returns: 

Time complexity: O(n),n is the number of elements in thevector.

References:

#include <igraph.h>#defineR_INTEGER(a,b) (igraph_rng_get_integer(igraph_rng_default(), (a), (b)))#defineR_UNIF(a,b) (igraph_rng_get_unif(igraph_rng_default(), (a), (b)))intmain(void) {    igraph_real_t d;igraph_vector_t u, v;    igraph_integer_t i, k, n;/********************************     * Example usage     ********************************//* Sequences with one element. Such sequences are trivially permuted.     * The result of any Fisher-Yates shuffle on a sequence with one element     * must be the original sequence itself.     */    n = 1;igraph_vector_init(&v, n);igraph_rng_seed(igraph_rng_default(), 42);/* make tests deterministic */    k =R_INTEGER(-1000, 1000);VECTOR(v)[0] = k;igraph_vector_shuffle(&v);if (VECTOR(v)[0] != k) {return 1;    }    d =R_UNIF(-1000.0, 1000.0);VECTOR(v)[0] = d;igraph_vector_shuffle(&v);if (VECTOR(v)[0] != d) {return 2;    }igraph_vector_destroy(&v);/* Sequences with multiple elements. A Fisher-Yates shuffle of a sequence S     * is a random permutation \pi(S) of S. Thus \pi(S) must have the same     * length and elements as the original sequence S. A major difference between     * S and its random permutation \pi(S) is that the order in which elements     * appear in \pi(S) is probably different from how elements are ordered in S.     * If S has length n = 1, then both \pi(S) and S are equivalent sequences in     * that \pi(S) is merely S and no permutation has taken place. If S has     * length n > 1, then there are n! possible permutations of S. Assume that     * each such permutation is equally likely to appear as a result of the     * Fisher-Yates shuffle. As n increases, the probability that S is different     * from \pi(S) also increases. We have a probability of 1 / n! that S and     * \pi(S) are equivalent sequences.     */    n = 100;igraph_vector_init(&u, n);igraph_vector_init(&v, n);for (i = 0; i < n; i++) {        k =R_INTEGER(-1000, 1000);VECTOR(u)[i] = k;VECTOR(v)[i] = k;    }igraph_vector_shuffle(&v);/* must have same length */if (igraph_vector_size(&v) != n) {return 3;    }if (igraph_vector_size(&u) !=igraph_vector_size(&v)) {return 4;    }/* must have same elements */igraph_vector_sort(&u);igraph_vector_sort(&v);if (!igraph_vector_all_e(&u, &v)) {return 5;    }igraph_vector_destroy(&u);igraph_vector_destroy(&v);/* empty sequence */igraph_vector_init(&v, 0);igraph_vector_shuffle(&v);igraph_vector_destroy(&v);return 0;}

igraph_error_t igraph_vector_permute(igraph_vector_t *v, const igraph_vector_int_t *index);

This function takes a vectorv and a corresponding index vectorind,and permutes the elements ofv such thatv[ind[i]] is moved to becomev[i] after the function is executed.

It is an error to call this function with an index vector that does notrepresent a valid permutation. Each element in the index vector must bebetween 0 and the length of the vector minus one (inclusive), and each suchelement must appear only once. The function does not attempt to validate theindex vector.

The index vector that this function takes is compatible with the index vectorreturned fromigraph_vector_sort_ind(); passing in the index vectorfromigraph_vector_sort_ind() will sort the original vector.

As a special case, this function allows the index vector to beshorterthan the vector being permuted, in which case the elements whose indices donot occur in the index vector will be removed from the vector.

Arguments: 

Returns: 

Time complexity: O(n), the size of the vector.

2.8.1.igraph_vector_add_constant — Add a constant to the vector.

2.8.2.igraph_vector_scale — Multiplies all elements of a vector by a constant.

2.8.3.igraph_vector_add — Add two vectors.

2.8.4.igraph_vector_sub — Subtract a vector from another one.

2.8.5.igraph_vector_mul — Multiply two vectors.

2.8.6.igraph_vector_div — Divide a vector by another one.

2.8.7.igraph_vector_floor — Transform a real vector to an integer vector by flooring each element.

void igraph_vector_add_constant(igraph_vector_t *v, igraph_real_t plus);

plus is added to every element ofv. Note that overflowmight happen.

Arguments: 

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

void igraph_vector_scale(igraph_vector_t *v, igraph_real_t by);

Arguments: 

Returns: 

Added in version 0.2.

Time complexity: O(n), the number of elements in a vector.

igraph_error_t igraph_vector_add(igraph_vector_t *v1,                                 const igraph_vector_t *v2);

Add the elements ofv2 tov1, the result is stored inv1. The two vectors must have the same length.

Arguments: 

Returns: 

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

igraph_error_t igraph_vector_sub(igraph_vector_t *v1,                                 const igraph_vector_t *v2);

Subtract the elements ofv2 fromv1, the result is stored inv1. The two vectors must have the same length.

Arguments: 

Returns: 

Time complexity: O(n), the length of the vectors.

igraph_error_t igraph_vector_mul(igraph_vector_t *v1,                                 const igraph_vector_t *v2);

v1 will be multiplied byv2, elementwise. The two vectorsmust have the same length.

Arguments: 

Returns: 

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

igraph_error_t igraph_vector_div(igraph_vector_t *v1,                                 const igraph_vector_t *v2);

v1 is divided byv2, elementwise. They must have the same length. If thebase type of the vector can generate divide by zero errors thenplease make sure thatv2 contains no zero if you want to avoidtrouble.

Arguments: 

Returns: 

Time complexity: O(n), the length of the vectors.

igraph_error_t igraph_vector_floor(const igraph_vector_t *from, igraph_vector_int_t *to);

Flooring means rounding down to the nearest integer.

Arguments: 

Returns: 

Time complexity: O(n), where n is the number of elements in the vector.

2.9.1.igraph_vector_all_e — Are all elements equal?

2.9.2.igraph_vector_all_almost_e — Are all elements almost equal?

2.9.3.igraph_vector_all_l — Are all elements less?

2.9.4.igraph_vector_all_g — Are all elements greater?

2.9.5.igraph_vector_all_le — Are all elements less or equal?

2.9.6.igraph_vector_all_ge — Are all elements greater or equal?

2.9.7.igraph_vector_is_equal — Are all elements equal?

2.9.8.igraph_vector_zapsmall — Replaces small elements of a vector by exact zeros.

2.9.9.igraph_vector_lex_cmp — Lexicographical comparison of two vectors (type-safe variant).

2.9.10.igraph_vector_lex_cmp_untyped — Lexicographical comparison of two vectors (non-type-safe).

2.9.11.igraph_vector_colex_cmp — Colexicographical comparison of two vectors.

2.9.12.igraph_vector_colex_cmp_untyped — Colexicographical comparison of two vectors.

igraph_bool_t igraph_vector_all_e(const igraph_vector_t *lhs,                                  const igraph_vector_t *rhs);

Checks element-wise equality of two vectors. For vectors containing floatingpoint values, consider usingigraph_matrix_all_almost_e().

Arguments: 

Returns: 

Time complexity: O(n), the length of the vectors.

igraph_bool_t igraph_vector_all_almost_e(const igraph_vector_t *lhs,                                         const igraph_vector_t *rhs,                                         igraph_real_t eps);

Checks if the elements of two vectors are equal within a relative tolerance.

Arguments: 

Returns: 

igraph_bool_t igraph_vector_all_l(const igraph_vector_t *lhs,                                  const igraph_vector_t *rhs);

Arguments: 

Returns: 

Time complexity: O(n), the length of the vectors.

igraph_bool_t igraph_vector_all_g(const igraph_vector_t *lhs,                                  const igraph_vector_t *rhs);

Arguments: 

Returns: 

Time complexity: O(n), the length of the vectors.

igraph_bool_t igraph_vector_all_le(const igraph_vector_t *lhs,                                   const igraph_vector_t *rhs);

Arguments: 

Returns: 

Time complexity: O(n), the length of the vectors.

igraph_bool_t igraph_vector_all_ge(const igraph_vector_t *lhs,                                   const igraph_vector_t *rhs);

Arguments: 

Returns: 

Time complexity: O(n), the length of the vectors.

igraph_bool_t igraph_vector_is_equal(const igraph_vector_t *lhs,                                     const igraph_vector_t *rhs);

This is an alias ofigraph_vector_all_e() with a more intuitive name.

Arguments: 

Returns: 

Time complexity: O(n), the length of the vectors.

igraph_error_t igraph_vector_zapsmall(igraph_vector_t *v, igraph_real_t tol);

Vector elements which are smaller in magnitude than the given absolutetolerance will be replaced by exact zeros. The default tolerancecorresponds to two-thirds of the representable digits ofigraph_real_t,i.e.DBL_EPSILON^(2/3) which is approximately10^-10.

Arguments: 

Returns: 

See also: 

int igraph_vector_lex_cmp(    const igraph_vector_t *lhs, const igraph_vector_t *rhs);

If the elements of two vectors match but one is shorter, the shorterone comes first. Thus {1, 3} comes after {1, 2, 3}, but before {1, 3, 4}.

This function is typically used together withigraph_vector_list_sort().

Arguments: 

Returns: 

See also: 

Time complexity: O(n), the number of elements in the smaller vector.

#include <igraph.h>#include <stdio.h>intmain(void) {    igraph_t graph;    igraph_vector_int_list_tcliques;    igraph_integer_t i, n;/* Set a random seed to make the program deterministic */igraph_rng_seed(igraph_rng_default(), 31415);/* Create a random graph with a given number of vertices and edges */igraph_erdos_renyi_game_gnm(&graph, 15, 80, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);/* Find all maximal cliques in the graph */igraph_vector_int_list_init(&cliques, 0);igraph_maximal_cliques(&graph, &cliques, -1, -1);/* Print the cliques in lexicographical order */printf("Maximalcliques in lexicographical order:\n");igraph_vector_int_list_sort(&cliques, igraph_vector_int_lex_cmp);    n =igraph_vector_int_list_size(&cliques);for (i=0; i < n; ++i) {igraph_vector_int_print(igraph_vector_int_list_get_ptr(&cliques, i));    }/* Print the cliques in colexicographical order */printf("\nMaximalcliques in colexicographical order:\n");igraph_vector_int_list_sort(&cliques, igraph_vector_int_colex_cmp);    n =igraph_vector_int_list_size(&cliques);for (i=0; i < n; ++i) {igraph_vector_int_print(igraph_vector_int_list_get_ptr(&cliques, i));    }/* Destroy data structures when we no longer need them */igraph_vector_int_list_destroy(&cliques);igraph_destroy(&graph);return 0;}

int igraph_vector_lex_cmp_untyped(const void *lhs, const void *rhs);

If the elements of two vectors match but one is shorter, the shorterone comes first. Thus {1, 3} comes after {1, 2, 3}, but before {1, 3, 4}.

This function is typically used together withigraph_vector_ptr_sort().

Arguments: 

Returns: 

See also: 

Time complexity: O(n), the number of elements in the smaller vector.

int igraph_vector_colex_cmp(    const igraph_vector_t *lhs, const igraph_vector_t *rhs);

This comparison starts from the last element of both vectors andmoves backward. If the elements of two vectors match but one isshorter, the shorter one comes first. Thus {1, 2} comes after {3, 2, 1},but before {0, 1, 2}.

This function is typically used together withigraph_vector_list_sort().

Arguments: 

Returns: 

See also: 

Time complexity: O(n), the number of elements in the smaller vector.

#include <igraph.h>#include <stdio.h>intmain(void) {    igraph_t graph;    igraph_vector_int_list_tcliques;    igraph_integer_t i, n;/* Set a random seed to make the program deterministic */igraph_rng_seed(igraph_rng_default(), 31415);/* Create a random graph with a given number of vertices and edges */igraph_erdos_renyi_game_gnm(&graph, 15, 80, IGRAPH_UNDIRECTED, IGRAPH_NO_LOOPS);/* Find all maximal cliques in the graph */igraph_vector_int_list_init(&cliques, 0);igraph_maximal_cliques(&graph, &cliques, -1, -1);/* Print the cliques in lexicographical order */printf("Maximalcliques in lexicographical order:\n");igraph_vector_int_list_sort(&cliques, igraph_vector_int_lex_cmp);    n =igraph_vector_int_list_size(&cliques);for (i=0; i < n; ++i) {igraph_vector_int_print(igraph_vector_int_list_get_ptr(&cliques, i));    }/* Print the cliques in colexicographical order */printf("\nMaximalcliques in colexicographical order:\n");igraph_vector_int_list_sort(&cliques, igraph_vector_int_colex_cmp);    n =igraph_vector_int_list_size(&cliques);for (i=0; i < n; ++i) {igraph_vector_int_print(igraph_vector_int_list_get_ptr(&cliques, i));    }/* Destroy data structures when we no longer need them */igraph_vector_int_list_destroy(&cliques);igraph_destroy(&graph);return 0;}

int igraph_vector_colex_cmp_untyped(const void *lhs, const void *rhs);

This comparison starts from the last element of both vectors andmoves backward. If the elements of two vectors match but one isshorter, the shorter one comes first. Thus {1, 2} comes after {3, 2, 1},but before {0, 1, 2}.

This function is typically used together withigraph_vector_ptr_sort().

Arguments: 

Returns: 

See also: 

Time complexity: O(n), the number of elements in the smaller vector.

2.10.1.igraph_vector_min — Smallest element of a vector.

2.10.2.igraph_vector_max — Largest element of a vector.

2.10.3.igraph_vector_which_min — Index of the smallest element.

2.10.4.igraph_vector_which_max — Gives the index of the maximum element of the vector.

2.10.5.igraph_vector_minmax — Minimum and maximum elements of a vector.

2.10.6.igraph_vector_which_minmax — Index of the minimum and maximum elements.

igraph_real_t igraph_vector_min(const igraph_vector_t *v);

The vector must not be empty.

Arguments: 

Returns: 

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

igraph_real_t igraph_vector_max(const igraph_vector_t *v);

The vector must not be empty.

Arguments: 

Returns: 

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

igraph_integer_t igraph_vector_which_min(const igraph_vector_t* v);

The vector must not be empty. If the smallest elementis not unique, then the index of the first is returned. If the vectorcontains NaN values, the index of the first NaN value is returned.

Arguments: 

Returns: 

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

igraph_integer_t igraph_vector_which_max(const igraph_vector_t *v);

The vector must not be empty. If the largestelement is not unique, then the index of the first is returned.If the vector contains NaN values, the index of the first NaN valueis returned.

Arguments: 

Returns: 

Time complexity: O(n), n is the size of the vector.

void igraph_vector_minmax(const igraph_vector_t *v,                          igraph_real_t *min, igraph_real_t *max);

Handy if you want to have both the smallest and largest element ofa vector. The vector is only traversed once. The vector must be non-empty.If a vector contains at least one NaN, bothmin andmax will be NaN.

Arguments: 

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

void igraph_vector_which_minmax(const igraph_vector_t *v,        igraph_integer_t *which_min, igraph_integer_t *which_max);

Handy if you need the indices of the smallest and largestelements. The vector is traversed only once. The vector must benon-empty. If the minimum or maximum is not unique, the indexof the first minimum or the first maximum is returned, respectively.If a vector contains at least one NaN, bothwhich_min andwhich_maxwill point to the first NaN value.

Arguments: 

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

2.11.1.igraph_vector_empty — Decides whether the size of the vector is zero.

2.11.2.igraph_vector_size — The size of the vector.

2.11.3.igraph_vector_capacity — Returns the allocated capacity of the vector.

2.11.4.igraph_vector_sum — Calculates the sum of the elements in the vector.

2.11.5.igraph_vector_prod — Calculates the product of the elements in the vector.

2.11.6.igraph_vector_isininterval — Checks if all elements of a vector are in the given interval.

2.11.7.igraph_vector_maxdifference — The maximum absolute difference ofm1 andm2.

2.11.8.igraph_vector_is_nan — Check for each element if it is NaN.

2.11.9.igraph_vector_is_any_nan — Check if any element is NaN.

2.11.10.igraph_vector_is_all_finite — Check if all elements are finite.

igraph_bool_t igraph_vector_empty(const igraph_vector_t *v);

Arguments: 

Returns: 

Time complexity: O(1).

igraph_integer_t igraph_vector_size(const igraph_vector_t *v);

Returns the number of elements stored in the vector.

Arguments: 

Returns: 

Time complexity: O(1).

igraph_integer_t igraph_vector_capacity(const igraph_vector_t *v);

Note that this might be different from the size of the vector (asqueried byigraph_vector_size()), and specifies how many elementsthe vector can hold, without reallocation.

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_real_t igraph_vector_sum(const igraph_vector_t *v);

For the empty vector 0 is returned.

Arguments: 

Returns: 

Time complexity: O(n), the size ofthe vector.

igraph_real_t igraph_vector_prod(const igraph_vector_t *v);

For the empty vector one (1) is returned.

Arguments: 

Returns: 

Time complexity: O(n), the size ofthe vector.

igraph_bool_t igraph_vector_isininterval(const igraph_vector_t *v,        igraph_real_t low,        igraph_real_t high);

Arguments: 

Returns: 

Time complexity: O(n), the number of elements in the vector.

igraph_real_t igraph_vector_maxdifference(const igraph_vector_t *m1,        const igraph_vector_t *m2);

The element with the largest absolute value inm1 -m2 isreturned. Both vectors must be non-empty, but they not need to havethe same length, the extra elements in the longer vector are ignored. Ifany value is NaN in the shorter vector, the result will be NaN.

Arguments: 

Returns: 

Time complexity: O(n), the number of elements in the shortervector.

igraph_error_t igraph_vector_is_nan(const igraph_vector_t *v, igraph_vector_bool_t *is_nan);

Arguments: 

Returns: 

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

igraph_bool_t igraph_vector_is_any_nan(const igraph_vector_t *v);

Arguments: 

Returns: 

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

igraph_bool_t igraph_vector_is_all_finite(const igraph_vector_t *v);

Arguments: 

Returns: 

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

2.12.1.igraph_vector_contains — Linear search in a vector.

2.12.2.igraph_vector_search — Searches in a vector from a given position.

2.12.3.igraph_vector_binsearch — Finds an element by binary searching a sorted vector.

2.12.4.igraph_vector_binsearch_slice — Finds an element by binary searching a sorted slice of a vector.

2.12.5.igraph_vector_contains_sorted — Binary search in a sorted vector.

igraph_bool_t igraph_vector_contains(const igraph_vector_t *v,        igraph_real_t what);

Check whether the supplied element is included in the vector, bylinear search.

Arguments: 

Returns: 

Time complexity: O(n), the length of the vector.

igraph_bool_t igraph_vector_search(const igraph_vector_t *v,        igraph_integer_t from, igraph_real_t what, igraph_integer_t *pos);

The supplied elementwhat is searched in vectorv, startingfrom element indexfrom. If found then the index of the firstinstance (afterfrom) is stored inpos.

Arguments: 

Returns: 

Time complexity: O(m), the number of elements to search, the lengthof the vector minus thefrom argument.

igraph_bool_t igraph_vector_binsearch(const igraph_vector_t *v,        igraph_real_t what, igraph_integer_t *pos);

It is assumed that the vector is sorted. If the specified element(what) is not in the vector, then theposition of where it should be inserted (to keep the vector sorted)is returned. If the vector contains any NaN values, the returnedvalue is undefined andpos may point to any position.

Arguments: 

Returns: 

Time complexity: O(log(n)),n is the number of elements inv.

igraph_bool_t igraph_vector_binsearch_slice(const igraph_vector_t *v,        igraph_real_t what, igraph_integer_t *pos, igraph_integer_t start, igraph_integer_t end);

It is assumed that the indicated slice of the vector, fromstart toend,is sorted. If the specified element (what) is not in the slice of thevector, then the position of where it should be inserted (to keep theslicesorted) is returned. Note that this means that the returned index will pointinside the slice (including its endpoints), but will not evaluate valuesoutside the slice. If the indicated slice contains any NaN values, thereturned value is undefined andpos may point to any position withinthe slice.

Arguments: 

Returns: 

Time complexity: O(log(n)),n is the number of elements in the slice ofv, i.e.end -start.

igraph_bool_t igraph_vector_contains_sorted(const igraph_vector_t *v, igraph_real_t what);

It is assumed that the vector is sorted.

Arguments: 

Returns: 

Time complexity: O(log(n)), n is the number of elements inv.

2.13.1.igraph_vector_clear — Removes all elements from a vector.

2.13.2.igraph_vector_reserve — Reserves memory for a vector.

2.13.3.igraph_vector_resize — Resize the vector.

2.13.4.igraph_vector_resize_min — Deallocate the unused memory of a vector.

2.13.5.igraph_vector_push_back — Appends one element to a vector.

2.13.6.igraph_vector_pop_back — Removes and returns the last element of a vector.

2.13.7.igraph_vector_insert — Inserts a single element into a vector.

2.13.8.igraph_vector_remove — Removes a single element from a vector.

2.13.9.igraph_vector_remove_section — Deletes a section from a vector.

void igraph_vector_clear(igraph_vector_t* v);

This function simply sets the size of the vector to zero, it doesnot free any allocated memory. For that you have to calligraph_vector_destroy().

Arguments: 

Time complexity: O(1).

igraph_error_t igraph_vector_reserve(igraph_vector_t *v, igraph_integer_t capacity);

igraph vectors are flexible, they can grow andshrink. Growinghowever occasionally needs the data in the vector to be copied.In order to avoid this, you can call this function to reserve space forfuture growth of the vector.

Note that this function doesnot change the size of thevector. Let us see a small example to clarify things: if youreserve space for 100 elements and the size of yourvector was (and still is) 60, then you can surely add additional 40elements to your vector before it will be copied.

Arguments: 

Returns: 

Time complexity: operating system dependent, should be aroundO(n), nis the new allocated size of the vector.

igraph_error_t igraph_vector_resize(igraph_vector_t* v, igraph_integer_t new_size);

Note that this function does not free any memory, just sets thesize of the vector to the given one. It can on the other handallocate more memory if the new size is larger than the previousone. In this case the newly appeared elements in the vector arenot set to zero, they are uninitialized.

Arguments: 

Returns: 

See also: 

Time complexity: O(1) if the newsize is smaller, operating system dependent if it is larger. In thelatter case it is usually aroundO(n),n is the new size of the vector.

void igraph_vector_resize_min(igraph_vector_t *v);

This function attempts to deallocate the unused reserved storageof a vector. If it succeeds,igraph_vector_size() andigraph_vector_capacity() will be the same. The data in thevector is always preserved, even if deallocation is not successful.

Arguments: 

See also: 

Time complexity: operating system dependent, O(n) at worst.

igraph_error_t igraph_vector_push_back(igraph_vector_t *v, igraph_real_t e);

This function resizes the vector to be one element longer andsets the very last element in the vector toe.

Arguments: 

Returns: 

Time complexity: operating system dependent. What is important is thata sequence of nsubsequent calls to this function has time complexityO(n), even if therehadn't been any space reserved for the new elements byigraph_vector_reserve(). This is implemented by a trick similar to the C++vector class: each time more memory is allocated for avector, the size of the additionally allocated memory is the sameas the vector's current length. (We assume here that the timecomplexity of memory allocation is at most linear.)

igraph_real_t igraph_vector_pop_back(igraph_vector_t *v);

It is an error to call this function with an empty vector.

Arguments: 

Returns: 

Time complexity: O(1).

igraph_error_t igraph_vector_insert(        igraph_vector_t *v, igraph_integer_t pos, igraph_real_t value);

Note that this function does not do range checking. Insertion will shift theelements from the position given to the end of the vector one position to theright, and the new element will be inserted in the empty space created atthe given position. The size of the vector will increase by one.

Arguments: 

void igraph_vector_remove(igraph_vector_t *v, igraph_integer_t elem);

Note that this function does not do range checking.

Arguments: 

Time complexity: O(n-elem),n is the number of elements in thevector.

void igraph_vector_remove_section(        igraph_vector_t *v, igraph_integer_t from, igraph_integer_t to);

Arguments: 

Time complexity: O(n-from),n is the number of elements in thevector.

2.14.1.igraph_vector_complex_real — Gives the real part of a complex vector.

2.14.2.igraph_vector_complex_imag — Gives the imaginary part of a complex vector.

2.14.3.igraph_vector_complex_realimag — Gives the real and imaginary parts of a complex vector.

2.14.4.igraph_vector_complex_create — Creates a complex vector from a real and imaginary part.

2.14.5.igraph_vector_complex_create_polar — Creates a complex matrix from a magnitude and an angle.

2.14.6.igraph_vector_complex_all_almost_e — Are all elements almost equal?

2.14.7.igraph_vector_complex_zapsmall — Replaces small elements of a complex vector by exact zeros.

igraph_error_t igraph_vector_complex_real(const igraph_vector_complex_t *v,                               igraph_vector_t *real);

Arguments: 

Returns: 

Time complexity: O(n), n is the number of elements in the vector.

igraph_error_t igraph_vector_complex_imag(const igraph_vector_complex_t *v,                               igraph_vector_t *imag);

Arguments: 

Returns: 

Time complexity: O(n), n is the number of elements in the vector.

igraph_error_t igraph_vector_complex_realimag(const igraph_vector_complex_t *v,                                   igraph_vector_t *real,                                   igraph_vector_t *imag);

Arguments: 

Returns: 

Time complexity: O(n), n is the number of elements in the vector.

igraph_error_t igraph_vector_complex_create(igraph_vector_complex_t *v,                                 const igraph_vector_t *real,                                 const igraph_vector_t *imag);

Arguments: 

Returns: 

Time complexity: O(n), n is the number of elements in the vector.

igraph_error_t igraph_vector_complex_create_polar(igraph_vector_complex_t *v,                                       const igraph_vector_t *r,                                       const igraph_vector_t *theta);

Arguments: 

Returns: 

Time complexity: O(n), n is the number of elements in the vector.

igraph_bool_t igraph_vector_complex_all_almost_e(const igraph_vector_complex_t *lhs,                                                 const igraph_vector_complex_t *rhs,                                                 igraph_real_t eps);

Checks if the elements of two complex vectors are equal within a relative tolerance.

Arguments: 

Returns: 

igraph_error_t igraph_vector_complex_zapsmall(igraph_vector_complex_t *v, igraph_real_t tol);

Similarly toigraph_vector_zapsmall(), small elements will be replacedby zeros. The operation is performed separately on the real and imaginaryparts of the numbers. This way, complex numbers with a large real part andtiny imaginary part will effectively be transformed to real numbers.The default tolerancecorresponds to two-thirds of the representable digits ofigraph_real_t,i.e.DBL_EPSILON^(2/3) which is approximately10^-10.

Arguments: 

Returns: 

See also: 

2.15.1.igraph_vector_sort — Sorts the elements of the vector into ascending order.

2.15.2.igraph_vector_reverse_sort — Sorts the elements of the vector into descending order.

2.15.3.igraph_vector_sort_ind — Returns a permutation of indices that sorts a vector.

void igraph_vector_sort(igraph_vector_t *v);

If the vector contains any NaN values, the resulting ordering ofNaN values is undefined and may appear anywhere in the vector.

Arguments: 

Time complexity:O(n log n) for n elements.

void igraph_vector_reverse_sort(igraph_vector_t *v);

If the vector contains any NaN values, the resulting ordering ofNaN values is undefined and may appear anywhere in the vector.

Arguments: 

Time complexity:O(n log n) for n elements.

igraph_error_t igraph_vector_sort_ind(        const igraph_vector_t *v,        igraph_vector_int_t *inds,        igraph_order_t order);

Takes an unsorted arrayv as input and computes an array of indicesinds such thatv[ inds[i] ], withi increasing from 0,is an ordered array (either ascending or descending, depending onorder). The order of indices for identical elements is notdefined. If the vector contains any NaN values, the ordering ofNaN values is undefined.

Arguments: 

Returns: 

This routine uses igraph's built-in qsort routine.Algorithm: 1) create an array of pointers to the elements of v. 2)Pass this array to qsort. 3) after sorting the difference betweenthe pointer value and the first pointer value gives its originalposition in the array. Use this to set the values of inds.

2.16.1.igraph_vector_intersect_sorted — Set intersection of two sorted vectors.

2.16.2.igraph_vector_intersection_size_sorted — Intersection size of two sorted vectors.

2.16.3.igraph_vector_difference_sorted — Set difference of two sorted vectors.

igraph_error_t igraph_vector_intersect_sorted(const igraph_vector_t *v1,        const igraph_vector_t *v2, igraph_vector_t *result);

The elements that are contained in both vectors are stored in the resultvector. All three vectors must be initialized.

For similar-size vectors, this function uses a straightforward linear scan.When the vector sizes differ substantially, it uses the set intersectionmethod of Ricardo Baeza-Yates, which takes logarithmic time in the lengthof the larger vector.

The algorithm keeps the multiplicities of the elements: if an element appearsk1 times in the first vector andk2 times in the second, the resultwill include that elementmin(k1, k2) times.

Reference:

Baeza-Yates R: A fast set intersection algorithm for sortedsequences. In: Lecture Notes in Computer Science, vol. 3109/2004, pp.400--408, 2004. Springer Berlin/Heidelberg.https://doi.org/10.1007/978-3-540-27801-6_30

Arguments: 

Returns: 

Time complexity: O(m log(n)) where m is the size of the smaller vectorand n is the size of the larger one.

igraph_integer_t igraph_vector_intersection_size_sorted(        const igraph_vector_t *v1,        const igraph_vector_t *v2);

Counts elements that are present in both vectors. This is particularlyuseful for counting common neighbours of two vertices.

For similar-size vectors, this function uses a straightforward linear scan.When the vector sizes differ substantially, it uses the set intersectionmethod of Ricardo Baeza-Yates, which takes logarithmic time in the lengthof the larger vector.

The algorithm keeps the multiplicities of the elements: if an element appearsk1 times in the first vector andk2 times in the second, the resultwill include that elementmin(k1, k2) times.

Reference:

Baeza-Yates R: A fast set intersection algorithm for sortedsequences. In: Lecture Notes in Computer Science, vol. 3109/2004, pp.400--408, 2004. Springer Berlin/Heidelberg.https://doi.org/10.1007/978-3-540-27801-6_30

Arguments: 

Returns: 

Time complexity: O(m log(n)) where m is the size of the smaller vectorand n is the size of the larger one.

igraph_error_t igraph_vector_difference_sorted(const igraph_vector_t *v1,        const igraph_vector_t *v2, igraph_vector_t *result);

The elements that are contained in only the first vector but not the second arestored in the result vector. All three vectors must be initialized.

Arguments: 

2.17.1.igraph_vector_ptr_init — Initialize a pointer vector (constructor).

2.17.2.igraph_vector_ptr_init_copy — Initializes a pointer vector from another one (constructor).

2.17.3.igraph_vector_ptr_destroy — Destroys a pointer vector.

2.17.4.igraph_vector_ptr_free_all — Frees all the elements of a pointer vector.

2.17.5.igraph_vector_ptr_destroy_all — Frees all the elements and destroys the pointer vector.

2.17.6.igraph_vector_ptr_size — Gives the number of elements in the pointer vector.

2.17.7.igraph_vector_ptr_clear — Removes all elements from a pointer vector.

2.17.8.igraph_vector_ptr_push_back — Appends an element to the back of a pointer vector.

2.17.9.igraph_vector_ptr_pop_back — Removes and returns the last element of a pointer vector.

2.17.10.igraph_vector_ptr_insert — Inserts a single element into a pointer vector.

2.17.11.igraph_vector_ptr_get — Access an element of a pointer vector.

2.17.12.igraph_vector_ptr_set — Assign to an element of a pointer vector.

2.17.13.igraph_vector_ptr_resize — Resizes a pointer vector.

2.17.14.igraph_vector_ptr_sort — Sorts the pointer vector based on an external comparison function.

2.17.15.igraph_vector_ptr_sort_ind — Returns a permutation of indices that sorts a vector of pointers.

2.17.16.igraph_vector_ptr_permute — Permutes the elements of a pointer vector in place according to an index vector.

2.17.17.igraph_vector_ptr_get_item_destructor — Gets the current item destructor for this pointer vector.

2.17.18.igraph_vector_ptr_set_item_destructor — Sets the item destructor for this pointer vector.

2.17.19.IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR — Sets the item destructor for this pointer vector (macro version).

igraph_error_t igraph_vector_ptr_init(igraph_vector_ptr_t* v, igraph_integer_t size);

This is the constructor of the pointer vector data type. Allpointer vectors constructed this way should be destroyed viacallingigraph_vector_ptr_destroy().

Arguments: 

Returns: 

Time complexity: operating system dependent, the amount of“time” required to allocatesize elements.

igraph_error_t igraph_vector_ptr_init_copy(igraph_vector_ptr_t *to, const igraph_vector_ptr_t *from);

This function creates a pointer vector by copying another one. Thisis shallow copy, only the pointers in the vector will be copied.

It is potentially dangerous to copy a pointer vector with an associateditem destructor. The copied vector will inherit the item destructor,which may cause problems when both vectors are destroyed as the itemsmight get destroyed twice. Make sure you know what you are doing whencopying a pointer vector with an item destructor, or unset the itemdestructor on one of the vectors later.

Arguments: 

Returns: 

Time complexity: O(n) if allocating memory for n elements can bedone in O(n) time.

void igraph_vector_ptr_destroy(igraph_vector_ptr_t* v);

The destructor for pointer vectors.

Arguments: 

Time complexity: operating system dependent, the“time” required to deallocate O(n) bytes, n is the number ofelements allocated for the pointer vector (not necessarily thenumber of elements in the vector).

void igraph_vector_ptr_free_all(igraph_vector_ptr_t* v);

If an item destructor is set for this pointer vector, this function willfirst call the destructor on all elements of the vector and thenfree all the elements usingigraph_free(). If an item destructor is not set,the elements will simply be freed.

Arguments: 

Time complexity: operating system dependent, the“time” required to call the destructor n times and thendeallocate O(n) pointers, each pointing to a memory area ofarbitrary size. n is the number of elements in the pointer vector.

void igraph_vector_ptr_destroy_all(igraph_vector_ptr_t* v);

This function is equivalent toigraph_vector_ptr_free_all()followed byigraph_vector_ptr_destroy().

Arguments: 

Time complexity: operating system dependent, the“time” required to deallocate O(n) pointers, each pointing toa memory area of arbitrary size, plus the“time”required to deallocate O(n) bytes, n being the number of elementsallocated for the pointer vector (not necessarily the number ofelements in the vector).

igraph_integer_t igraph_vector_ptr_size(const igraph_vector_ptr_t* v);

Arguments: 

Returns: 

Time complexity: O(1).

void igraph_vector_ptr_clear(igraph_vector_ptr_t* v);

This function resizes a pointer to vector to zero length. Note thatthe pointed objects arenot deallocated, you should calligraph_free() on them, or make sure that their allocated memory is freedin some other way, you'll get memory leaks otherwise. If you haveset up an item destructor earlier, the destructor will be calledon every element.

Note that the current implementation of this function doesnot deallocate the memory required for storing thepointers, so making a pointer vector smaller this way does not giveback any memory. This behavior might change in the future.

Arguments: 

Time complexity: O(1).

igraph_error_t igraph_vector_ptr_push_back(igraph_vector_ptr_t* v, void* e);

Arguments: 

Returns: 

See also: 

Time complexity: O(1) or O(n), n is the number of elements in thevector. The pointer vector implementation ensures that n subsequentpush_back operations need O(n) time to complete.

void *igraph_vector_ptr_pop_back(igraph_vector_ptr_t *v);

It is an error to call this function with an empty vector.

Arguments: 

Returns: 

Time complexity: O(1).

igraph_error_t igraph_vector_ptr_insert(igraph_vector_ptr_t* v, igraph_integer_t pos, void* e);

Note that this function does not do range checking. Insertion will shift theelements from the position given to the end of the vector one position to theright, and the new element will be inserted in the empty space created atthe given position. The size of the vector will increase by one.

Arguments: 

void *igraph_vector_ptr_get(const igraph_vector_ptr_t* v, igraph_integer_t pos);

Arguments: 

Returns: 

Time complexity: O(1).

void igraph_vector_ptr_set(igraph_vector_ptr_t* v, igraph_integer_t pos, void* value);

Arguments: 

Time complexity: O(1).

igraph_error_t igraph_vector_ptr_resize(igraph_vector_ptr_t* v, igraph_integer_t newsize);

Note that if a vector is made smaller the pointed object are notdeallocated by this function and the item destructor is not calledon the extra elements.

Arguments: 

Returns: 

Time complexity: O(1) if the vector if made smaller. Operatingsystem dependent otherwise, the amount of“time”needed to allocate the memory for the vector elements.

void igraph_vector_ptr_sort(igraph_vector_ptr_t *v, int (*compar)(const void*, const void*));

Sometimes it is necessary to sort the pointers in the vector based onthe property of the element being referenced by the pointer. Thisfunction allows us to sort the vector based on an arbitrary externalcomparison function which accepts twovoid * pointersp1 andp2and returns an integer less than, equal to or greater than zero if thefirst argument is considered to be respectively less than, equal to, orgreater than the second.p1 andp2 will point to the pointer in thevector, so they have to be double-dereferenced if one wants to get accessto the underlying object the address of which is stored inv.

Arguments: 

igraph_error_t igraph_vector_ptr_sort_ind(igraph_vector_ptr_t *v,        igraph_vector_int_t *inds, cmp_t *cmp);

Takes an unsorted arrayv as input and computes an array ofindices inds such that v[ inds[i] ], with i increasing from 0, isan ordered array (either ascending or descending, depending on\v order). The order of indices for identical elements is notdefined.

Arguments: 

Returns: 

This routine uses the C library qsort routine.Algorithm: 1) create an array of pointers to the elements of v. 2)Pass this array to qsort. 3) after sorting the difference betweenthe pointer value and the first pointer value gives its originalposition in the array. Use this to set the values of inds.

igraph_error_t igraph_vector_ptr_permute(igraph_vector_ptr_t* v, const igraph_vector_int_t* index);

This function takes a vectorv and a corresponding index vectorind,and permutes the elements ofv such thatv[ind[i]] is moved to becomev[i] after the function is executed.

It is an error to call this function with an index vector that does notrepresent a valid permutation. Each element in the index vector must bebetween 0 and the length of the vector minus one (inclusive), and each suchelement must appear only once. The function does not attempt to validate theindex vector.

The index vector that this function takes is compatible with the index vectorreturned fromigraph_vector_ptr_sort_ind(); passing in the index vectorfromigraph_vector_ptr_sort_ind() will sort the original vector.

As a special case, this function allows the index vector to beshorterthan the vector being permuted, in which case the elements whose indices donot occur in the index vector will be removed from the vector.

Arguments: 

Returns: 

Time complexity: O(n), the size of the vector.

igraph_finally_func_t* igraph_vector_ptr_get_item_destructor(const igraph_vector_ptr_t *v);

The item destructor is a function which will be called on every non-nullpointer stored in this vector whenigraph_vector_ptr_destroy(),igraph_vector_ptr_destroy_all() origraph_vector_ptr_free_all()is called.

Returns: 

Time complexity: O(1).

igraph_finally_func_t* igraph_vector_ptr_set_item_destructor(    igraph_vector_ptr_t *v, igraph_finally_func_t *func);

The item destructor is a function which will be called on every non-nullpointer stored in this vector whenigraph_vector_ptr_destroy(),igraph_vector_ptr_destroy_all() origraph_vector_ptr_free_all()is called.

Returns: 

Time complexity: O(1).

#define IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(v, func)

This macro is expanded toigraph_vector_ptr_set_item_destructor(), theonly difference is that the second argument is automatically cast to anigraph_finally_func_t*. The cast is necessary in most cases as thedestructor functions we use (such asigraph_vector_destroy()) take apointer to some concrete igraph data type, whileigraph_finally_func_texpectsvoid*

2.18.1.igraph_vector_copy — Initializes a vector from another vector object (deprecated alias).

2.18.2.igraph_vector_e — Access an element of a vector (deprecated alias).

2.18.3.igraph_vector_e_ptr — Get the address of an element of a vector.

2.18.4.igraph_vector_init_seq — Initializes a vector with a sequence, inclusive endpoints (deprecated).

2.18.5.igraph_vector_ptr_copy — Initializes a pointer vector from another one (deprecated alias).

2.18.6.igraph_vector_ptr_e — Access an element of a pointer vector (deprecated alias).

2.18.7.igraph_vector_qsort_ind — Returns a permutation of indices that sorts a vector (deprecated alias).

2.18.8.igraph_vector_binsearch2 — Binary search, without returning the index.

igraph_real_t* igraph_vector_e_ptr(const igraph_vector_t *v, igraph_integer_t pos);

Arguments: 

Returns: 

See also: 

Time complexity: O(1).

igraph_error_t igraph_vector_init_seq(igraph_vector_t *v, igraph_real_t from, igraph_real_t to);

The vector will contain the numbersfrom,from+1, ...,to. Note thatboth endpoints areinclusive, contrary to typical usage of ranges in C.

Arguments: 

Returns: 

Time complexity: O(n), the numberof elements in the vector.

3.2.1.igraph_matrix_init — Initializes a matrix.

3.2.2.igraph_matrix_init_array — Initializes a matrix from an ordinary C array (constructor).

3.2.3.igraph_matrix_init_copy — Copies a matrix.

3.2.4.igraph_matrix_destroy — Destroys a matrix object.

igraph_error_t igraph_matrix_init(        igraph_matrix_t *m, igraph_integer_t nrow, igraph_integer_t ncol);

Every matrix needs to be initialized before using it. This is doneby calling this function. A matrix has to be destroyed if it is notneeded any more; seeigraph_matrix_destroy().

Arguments: 

Returns: 

Time complexity: usually O(n), n is the number of elements in the matrix.

igraph_error_t igraph_matrix_init_array(        igraph_matrix_t *m, const igraph_real_t *data,        igraph_integer_t nrow, igraph_integer_t ncol,        igraph_matrix_storage_t storage);

The array is assumed to store the matrix data contiguously, either ina column-major or row-major format. In other words,data maystore concatenated matrix columns or concatenated matrix rows.Constructing a matrix from column-major data is faster, as this isigraph's native storage format.

Arguments: 

Returns: 

Time complexity: operating system specific, usuallyO(nrowncol).

igraph_error_t igraph_matrix_init_copy(igraph_matrix_t *to, const igraph_matrix_t *from);

Creates a matrix object by copying from an existing matrix.

Arguments: 

Returns: 

Time complexity: O(n), the numberof elements in the matrix.

void igraph_matrix_destroy(igraph_matrix_t *m);

This function frees all the memory allocated for a matrixobject. The destroyed object needs to be reinitialized before usingit again.

Arguments: 

Time complexity: operating system dependent.