All functions

Every function, type and macro of Open Graph, 1,162 entries, in one list: its name opens its entry, with the signature, parameters, errors and how it is checked.

The names are shown without the og_ prefix of their C names. Filter by a word of the name or the line, by a C name or by an igraph name (pagerank, og_pagerank and igraph_pagerank all find it); narrow it to one page, to how the entries are checked, or to those that use threads or SIMD.

1,162 entries

Name and page	Checked	What it does
`abi_error_clear`Binary interface	Unit tests Extension	Forgets the error kept on this thread.
`abi_error_handler`Binary interface	Unit tests Extension	An error handler that keeps the latest error's text on its thread, for hosts that cannot take a callback.
`abi_error_last`Binary interface	Unit tests Extension	What `abi_error_handler` kept on this thread: the reason, code, file and line.
`abi_offsetof`Binary interface	Unit tests Extension	The offset in bytes of a field of a public struct.
`abi_sizeof`Binary interface	Unit tests Extension	The size in bytes of a public type, looked up by its C name.
`abi_type`Binary interface	Unit tests Extension	The names of the public types `abi_sizeof` knows, one by one.
`ABI_VERSION`Binary interface	Unit tests Extension	The version of Open Graph's binary interface, for bindings in other languages.
`abi_version`Binary interface	Unit tests Extension	The version of the binary interface the library was built with.
`abi_warning_handler`Binary interface	Unit tests Extension	A warning handler that keeps the warnings on their thread, for hosts that cannot take a callback.
`abi_warnings`Binary interface	Unit tests Extension	The warnings kept on this thread, one per line.
`abi_warnings_clear`Binary interface	Unit tests Extension	Forgets the warnings kept on this thread.
`add_edge`Graph basics	Unit tests	Adds one edge.
`add_edges`Graph basics	Exact	Adds a batch of edges.
`add_vertices`Graph basics	Unit tests	Adds isolated vertices.
`adhesion`Flows, cuts and traversal	Exact	Adhesion of a graph, which is its edge connectivity.
`adjacency`Deterministic generators	Exact	Builds a graph from a square matrix of edge counts.
`adjacency_spectral_embedding`Linear algebra and embeddings	Within tolerance SIMD	Places the vertices in n dimensions using the leading eigenvectors (undirected) or singular vectors (directed) of the adjacency matrix.
`adjlist`Deterministic generators	Unit tests	Turns an adjacency list, one neighbour list per vertex, into a graph.
`adjlist_clear`String vectors, lists and bit sets	Unit tests	Empties every vertex's vector and keeps the number of vertices.
`adjlist_destroy`String vectors, lists and bit sets	Unit tests	Releases an adjacency list with all its vectors.
`adjlist_get`String vectors, lists and bit sets	Exact	Gives the neighbour vector of a vertex in an adjacency list.
`adjlist_init`String vectors, lists and bit sets	Exact	Builds a list of every vertex's neighbours.
`adjlist_init_complementer`String vectors, lists and bit sets	Exact	Builds, for each vertex, the list of vertices it is not joined to.
`adjlist_init_empty`String vectors, lists and bit sets	Unit tests	Creates an adjacency list of n vertices with no neighbours.
`adjlist_init_from_inclist`String vectors, lists and bit sets	Exact	Turns an incidence list into an adjacency list that lines up with it.
`adjlist_simplify`String vectors, lists and bit sets	Unit tests	Removes self-references and repeated entries from every vertex's vector.
`adjlist_size`String vectors, lists and bit sets	Exact	Tells how many vertices an adjacency list covers.
`adjlist_sort`String vectors, lists and bit sets	Exact	Sorts every vertex's vector in increasing order.
`all_minimal_st_separators`Cliques, independent sets and colouring	Exact	Lists every vertex set that minimally separates some pair of vertices.
`all_st_cuts`Flows, cuts and traversal	Exact	Lists every minimal s-t edge cut of a directed graph.
`all_st_mincuts`Flows, cuts and traversal	Exact	Lists every minimum-capacity s-t edge cut of a directed graph.
`almost_equals`Spatial graphs and numbers	Unit tests	Tells whether two doubles are equal within a relative tolerance.
`are_adjacent`Components and structure	Exact	Tells whether there is an edge from one vertex to another.
`arpack_function_t`Linear algebra and embeddings	Unit tests	The callback type through which the iterative eigensolvers multiply by the matrix.
`arpack_options_init`Linear algebra and embeddings	Unit tests	Fills an `arpack_options_t` with the default settings.
`arpack_options_t`Linear algebra and embeddings	Unit tests	Settings and run statistics of the iterative eigensolvers `arpack_rssolve` and `arpack_rnsolve`.
`arpack_rnsolve`Linear algebra and embeddings	Within tolerance SIMD	Finds a few eigenvalues and eigenvectors of a real non-symmetric matrix that is given only as a matrix-vector product.
`arpack_rssolve`Linear algebra and embeddings	Within tolerance SIMD	Finds a few eigenvalues and eigenvectors of a real symmetric matrix that is given only as a matrix-vector product.
`arpack_storage_destroy`Linear algebra and embeddings	Unit tests	Frees the memory of an `arpack_storage_t`.
`arpack_storage_init`Linear algebra and embeddings	Unit tests	Allocates reusable work memory for the iterative eigensolvers.
`arpack_storage_t`Linear algebra and embeddings	Unit tests	Work memory for `arpack_rssolve` and `arpack_rnsolve` that can be reused across calls.
`arpack_unpack_complex`Linear algebra and embeddings	Unit tests	Rewrites `arpack_rnsolve`'s output so that every eigenvalue has its own complex eigenvector.
`ARRAY3`Matrices, stacks, queues and heaps	Unit tests	Unchecked access to element (i, j, k) of any three-dimensional array.
`array3_destroy`Matrices, stacks, queues and heaps	Unit tests	Frees the storage of a three-dimensional array.
`array3_fill`Matrices, stacks, queues and heaps	Unit tests	Sets every element of a three-dimensional array to one value.
`array3_init`Matrices, stacks, queues and heaps	Unit tests	Creates an n1 x n2 x n3 array with every element zero.
`array3_n1`Matrices, stacks, queues and heaps	Unit tests	Returns the first dimension of a three-dimensional array.
`array3_n2`Matrices, stacks, queues and heaps	Unit tests	Returns the second dimension of a three-dimensional array.
`array3_n3`Matrices, stacks, queues and heaps	Unit tests	Returns the third dimension of a three-dimensional array.
`array3_null`Matrices, stacks, queues and heaps	Unit tests	Sets every element of a three-dimensional array to zero.
`array3_resize`Matrices, stacks, queues and heaps	Unit tests	Changes the dimensions of a three-dimensional array.
`array3_scale`Matrices, stacks, queues and heaps	Unit tests	Multiplies every element of a three-dimensional array by a constant.
`array3_size`Matrices, stacks, queues and heaps	Unit tests	Returns the number of elements, n1 n2 n3.
`array3_sum`Matrices, stacks, queues and heaps	Unit tests	Returns the sum of all elements of a three-dimensional array.
`array3_t`Matrices, stacks, queues and heaps	Unit tests	A dense three-dimensional array of real numbers.
`array3_update`Matrices, stacks, queues and heaps	Unit tests	Makes an existing three-dimensional array a copy of another.
`articulation_points`Components and structure	Exact	Lists the vertices whose removal splits their component.
`assortativity`Similarity, transitivity and mixing	Exact	Measures the correlation of a vertex value across the ends of the edges.
`assortativity_degree`Similarity, transitivity and mixing	Exact	Measures whether vertices connect to vertices of similar degree.
`assortativity_nominal`Similarity, transitivity and mixing	Exact	Measures whether edges tend to join vertices of the same category.
`astar_heuristic_func_t`Paths and distances	Unit tests	Callback type for the A* distance estimate.
`asymmetric_preference_game`Random graphs	Same quality	Draws a directed graph in which each vertex has an out-type and an in-type.
`atlas`Deterministic generators	Exact	Builds graph number k of An Atlas of Graphs: every graph with up to 7 vertices.
`attribute_combination`Attributes	Unit tests	Creates a list of combination rules from a variable argument list.
`attribute_combination_add`Attributes	Exact	Adds a rule saying how one attribute, or every other attribute, is combined.
`attribute_combination_destroy`Attributes	Unit tests	Frees a list of combination rules.
`attribute_combination_init`Attributes	Exact	Creates an empty list of combination rules.
`attribute_combination_remove`Attributes	Unit tests	Removes the rule for a name from a combination list.
`attribute_combination_type_t`Attributes	Exact	How the values of merged vertices or edges are turned into one value.
`attribute_elemtype_t`Attributes	Unit tests	Says whether an attribute belongs to the graph, to its vertices or to its edges.
`attribute_record_destroy`Attributes	Unit tests	Releases everything an attribute record owns: name, values and default.
`attribute_record_init`Attributes	Unit tests	Sets up a record with a name, a type and no values yet.
`attribute_record_init_copy`Attributes	Unit tests	Creates a deep copy of an attribute record.
`attribute_record_resize`Attributes	Unit tests	Changes the number of values of a record, filling new slots with its default.
`attribute_record_set_default_boolean`Attributes	Unit tests	Sets the value that new slots of a Boolean record receive.
`attribute_record_set_default_numeric`Attributes	Unit tests	Sets the value that new slots of a numeric record receive.
`attribute_record_set_default_string`Attributes	Unit tests	Sets the string that new slots of a string record receive.
`attribute_record_set_name`Attributes	Unit tests	Renames an attribute record.
`attribute_record_set_type`Attributes	Unit tests	Changes the type of a record, dropping its values.
`attribute_record_size`Attributes	Unit tests	Returns the number of values in an attribute record.
`attribute_record_t`Attributes	Unit tests	A named attribute: its type, its values and a default value.
`attribute_table_t`Attributes	Unit tests	The callbacks through which an attribute handler keeps values for graphs, vertices and edges.
`attribute_type_t`Attributes	Unit tests	The kind of value an attribute holds.
`automorphism_group`Isomorphism	Exact	Returns permutations that generate the automorphism group of a graph.
`automorphism_group_bliss`Isomorphism	Exact	Returns generators of the automorphism group, with a chosen heuristic and run statistics.
`average_local_efficiency`Paths and distances	Exact	The mean local efficiency over all vertices.
`average_path_length`Paths and distances	Exact Threads	Mean shortest-path length over the ordered pairs of distinct vertices that are connected.
`avg_nearest_neighbor_degree`Similarity, transitivity and mixing	Exact	Computes the average degree of each vertex's neighbours, and its average per degree.
`barabasi_aging_game`Random graphs	Same quality	Grows a graph by preferential attachment with aging: attractiveness also depends on a vertex's age.
`barabasi_game`Random graphs	Same quality	Grows a graph by preferential attachment (Barabási-Albert and its generalisations).
`beta_weighted_gabriel_graph`Spatial graphs and numbers	Unit tests	Builds the Gabriel graph and gives each edge the beta at which it leaves the lune-based beta-skeleton.
`betweenness`Centrality	Exact Threads	Vertex betweenness: how many shortest paths between other vertices pass through each vertex.
`betweenness_cutoff`Centrality	Exact Threads	Vertex betweenness counting only shortest paths no longer than a cutoff.
`betweenness_subset`Centrality	Exact Threads	Vertex betweenness counting only shortest paths from chosen sources to chosen targets.
`bfs`Flows, cuts and traversal	Exact	Breadth-first search with several roots, a restricted vertex set and an optional callback.
`bfs_simple`Flows, cuts and traversal	Exact	Breadth-first search from one vertex: visiting order, distance layers and parents.
`bfshandler_t`Flows, cuts and traversal	Unit tests	Type of the `bfs` callback.
`biadjacency`Operators and bipartite graphs	Exact	Builds a bipartite graph from its biadjacency matrix.
`bibcoupling`Similarity, transitivity and mixing	Exact	Counts, for pairs of vertices, how many vertices both of them point to.
`biconnected_components`Components and structure	Exact	Finds the biconnected components of a graph and its articulation points.
`bipartite_game_gnm`Operators and bipartite graphs	Same quality	Random bipartite graph with exactly m edges, G(n1, n2, m).
`bipartite_game_gnp`Operators and bipartite graphs	Same quality	Random bipartite graph in which each possible edge appears with probability p, G(n1, n2, p).
`bipartite_iea_game`Operators and bipartite graphs	Same quality	Random bipartite multigraph from m independently placed edges.
`bipartite_projection`Operators and bipartite graphs	Exact	The two one-mode projections of a bipartite graph.
`bipartite_projection_size`Operators and bipartite graphs	Exact	Vertex and edge counts of the two one-mode projections, without building them.
`bitset_and`String vectors, lists and bit sets	Unit tests SIMD	Combines two bitsets bit by bit with AND, writing the result into a third.
`bitset_capacity`String vectors, lists and bit sets	Unit tests	Returns how many bits fit before the bitset must reallocate.
`bitset_countl_one`String vectors, lists and bit sets	Unit tests	Counts the one bits from the highest bit (bit size-1) downward, up to the first zero bit.
`bitset_countl_zero`String vectors, lists and bit sets	Unit tests	Counts the zero bits from the highest bit (bit size-1) downward, up to the first one bit.
`bitset_countr_one`String vectors, lists and bit sets	Unit tests	Counts the one bits from bit 0 upward, up to the first zero bit.
`bitset_countr_zero`String vectors, lists and bit sets	Unit tests	Counts the zero bits from bit 0 upward, up to the first one bit.
`bitset_destroy`String vectors, lists and bit sets	Unit tests	Frees a bitset.
`bitset_fill`String vectors, lists and bit sets	Unit tests	Sets every bit of a bitset to the same value.
`bitset_init`String vectors, lists and bit sets	Unit tests	Creates a bitset of `size` bits, all zero.
`bitset_init_copy`String vectors, lists and bit sets	Unit tests	Creates a bitset with the same size and bits as another.
`bitset_is_all_one`String vectors, lists and bit sets	Unit tests	Tells whether every bit of a bitset is set.
`bitset_is_all_zero`String vectors, lists and bit sets	Unit tests	Tells whether no bit of a bitset is set.
`bitset_is_any_one`String vectors, lists and bit sets	Unit tests	Tells whether at least one bit of a bitset is set.
`bitset_is_any_zero`String vectors, lists and bit sets	Unit tests	Tells whether at least one bit of a bitset is clear.
`bitset_not`String vectors, lists and bit sets	Unit tests	Writes a bitset with every bit flipped.
`bitset_null`String vectors, lists and bit sets	Unit tests	Sets every bit of a bitset to zero.
`bitset_or`String vectors, lists and bit sets	Unit tests SIMD	Combines two bitsets bit by bit with OR, writing the result into a third.
`bitset_popcount`String vectors, lists and bit sets	Unit tests SIMD	Counts the bits that are set.
`bitset_reserve`String vectors, lists and bit sets	Unit tests	Allocates storage for at least `capacity` bits.
`bitset_resize`String vectors, lists and bit sets	Unit tests	Changes the number of bits of a bitset; new bits are zero.
`bitset_size`String vectors, lists and bit sets	Unit tests	Tells how many bits a bitset holds.
`bitset_t`Vectors	Unit tests	An array of bits stored in 64-bit words.
`bitset_update`String vectors, lists and bit sets	Unit tests	Makes one bitset a copy of another, size included.
`bitset_xor`String vectors, lists and bit sets	Unit tests SIMD	Combines two bitsets bit by bit with exclusive OR, writing the result into a third.
`blas_ddot`Linear algebra and embeddings	Within tolerance SIMD	Computes the dot product of two real vectors of equal length.
`blas_dgemm`Linear algebra and embeddings	Within tolerance SIMD	Computes C = alpha op(A) op(B) + beta C, where op is the matrix itself or its transpose.
`blas_dgemv`Linear algebra and embeddings	Within tolerance SIMD	Computes y = alpha A x + beta y, or the same with A transposed.
`blas_dgemv_array`Linear algebra and embeddings	Within tolerance SIMD	The product of `blas_dgemv` with plain arrays for x and y.
`blas_dnrm2`Linear algebra and embeddings	Within tolerance SIMD	Returns the Euclidean norm of a real vector, without needless overflow or underflow.
`bliss_info_t`Isomorphism	Unit tests	Statistics of one canonical labelling run, with the exact order of the automorphism group.
`bliss_sh_t`Isomorphism	Unit tests	How the canonical labelling search chooses the cell to split at each search node.
`bond_percolation`Components and structure	Unit tests	Adds edges one by one and records the size of the largest component after each.
`bridges`Components and structure	Exact	Lists the edges whose removal splits their component.
`callaway_traits_game`Random graphs	Same quality	Grows a graph in which random vertex pairs connect with a probability set by their types.
`calloc`Graph basics	Unit tests	Allocates zero-filled memory for an array.
`canonical_permutation`Isomorphism	Unit tests	Computes a canonical relabelling: isomorphic graphs relabelled this way become identical.
`canonical_permutation_bliss`Isomorphism	Unit tests	Computes a canonical relabelling with a chosen heuristic and run statistics.
`cattribute_EAB`Attributes	Exact	Returns the Boolean value one edge has for an attribute.
`cattribute_EAB_set`Attributes	Exact	Stores a Boolean value for one edge, creating the attribute when missing.
`cattribute_EAB_setv`Attributes	Exact	Fills the Boolean attribute of every edge from a vector, one value each.
`cattribute_EABV`Attributes	Unit tests	Copies the Boolean values of an attribute for selected edges into a vector.
`cattribute_EAN`Attributes	Exact	Returns the numeric value one edge has for an attribute.
`cattribute_EAN_set`Attributes	Exact	Stores a numeric value for one edge, creating the attribute when missing.
`cattribute_EAN_setv`Attributes	Exact	Fills the numeric attribute of every edge from a vector, one value each.
`cattribute_EANV`Attributes	Unit tests	Copies the numeric values of an attribute for selected edges into a vector.
`cattribute_EAS`Attributes	Exact	Returns the string value one edge has for an attribute.
`cattribute_EAS_set`Attributes	Exact	Stores a string value for one edge, creating the attribute when missing.
`cattribute_EAS_setv`Attributes	Exact	Fills the string attribute of every edge from a vector, one value each.
`cattribute_EASV`Attributes	Unit tests	Copies the string values of an attribute for selected edges into a vector.
`cattribute_GAB`Attributes	Exact	Returns the value of a Boolean attribute of the graph.
`cattribute_GAB_set`Attributes	Exact	Stores a Boolean value as a graph attribute, creating it when missing.
`cattribute_GAN`Attributes	Exact	Returns the value of a numeric attribute of the graph.
`cattribute_GAN_set`Attributes	Exact	Stores a numeric value as a graph attribute, creating it when missing.
`cattribute_GAS`Attributes	Exact	Returns the value of a string attribute of the graph.
`cattribute_GAS_set`Attributes	Exact	Stores a string value as a graph attribute, creating it when missing.
`cattribute_has_attr`Attributes	Exact	Tells whether a graph has an attribute of a given kind and name.
`cattribute_list`Attributes	Exact	Lists the names and types of a graph's attributes.
`cattribute_remove_all`Attributes	Exact	Deletes every attribute of the chosen kinds: graph, vertex and/or edge.
`cattribute_remove_e`Attributes	Exact	Deletes the edge attribute of a given name.
`cattribute_remove_g`Attributes	Exact	Deletes the graph attribute of a given name.
`cattribute_remove_v`Attributes	Exact	Deletes the vertex attribute of a given name.
`cattribute_VAB`Attributes	Exact	Returns the Boolean value one vertex has for an attribute.
`cattribute_VAB_set`Attributes	Exact	Stores a Boolean value for one vertex, creating the attribute when missing.
`cattribute_VAB_setv`Attributes	Exact	Fills the Boolean attribute of every vertex from a vector, one value each.
`cattribute_VABV`Attributes	Unit tests	Copies the Boolean values of an attribute for selected vertices into a vector.
`cattribute_VAN`Attributes	Exact	Returns the numeric value one vertex has for an attribute.
`cattribute_VAN_set`Attributes	Exact	Stores a numeric value for one vertex, creating the attribute when missing.
`cattribute_VAN_setv`Attributes	Exact	Fills the numeric attribute of every vertex from a vector, one value each.
`cattribute_VANV`Attributes	Unit tests	Copies the numeric values of an attribute for selected vertices into a vector.
`cattribute_VAS`Attributes	Exact	Returns the string value one vertex has for an attribute.
`cattribute_VAS_set`Attributes	Exact	Stores a string value for one vertex, creating the attribute when missing.
`cattribute_VAS_setv`Attributes	Exact	Fills the string attribute of every vertex from a vector, one value each.
`cattribute_VASV`Attributes	Unit tests	Copies the string values of an attribute for selected vertices into a vector.
`centralization`Centrality	Exact	Freeman centralization of a score vector: the total gap between the top score and every score.
`centralization_betweenness`Centrality	Exact Threads	Betweenness of every vertex and the graph's betweenness centralization.
`centralization_betweenness_tmax`Centrality	Exact	The largest betweenness centralization a graph of the given size can have.
`centralization_closeness`Centrality	Exact Threads	Normalised closeness of every vertex and the graph's closeness centralization.
`centralization_closeness_tmax`Centrality	Exact	The largest closeness centralization a graph of the given size can have.
`centralization_degree`Centrality	Exact	Degree of every vertex and the graph's degree centralization.
`centralization_degree_tmax`Centrality	Exact	The largest degree centralization a graph of the given size can have.
`centralization_eigenvector_centrality`Centrality	Within tolerance SIMD	Eigenvector centrality of every vertex and the graph's eigenvector centralization.
`centralization_eigenvector_centrality_tmax`Centrality	Exact	The largest eigenvector centralization a graph of the given size can have.
`chung_lu_game`Random graphs	Same quality	Draws a random graph with given expected degrees (the Chung-Lu model and two variants).
`circle_beta_skeleton`Spatial graphs and numbers	Unit tests	Builds the circle-based beta-skeleton of a planar point set.
`circulant`Deterministic generators	Exact	Builds a circulant graph: every vertex joined to the vertices a fixed set of offsets away.
`cited_type_game`Random graphs	Same quality	Grows a citation graph in which the chance of being cited depends on the cited vertex's type.
`citing_cited_type_game`Random graphs	Same quality	Grows a citation graph in which the chance of a citation depends on both vertices' types.
`clique_handler_t`Cliques, independent sets and colouring	Unit tests	Type of the function that receives cliques from the callback searches.
`clique_number`Cliques, independent sets and colouring	Exact	Size of the largest clique.
`clique_size_hist`Cliques, independent sets and colouring	Exact	Counts the cliques of each size.
`cliques`Cliques, independent sets and colouring	Exact	Lists every clique whose size lies in a given range.
`cliques_callback`Cliques, independent sets and colouring	Exact	Passes every clique in a size range to a function instead of storing it.
`closeness`Centrality	Exact Threads	Closeness centrality: the inverse of the total distance from each vertex to the vertices it reaches.
`closeness_cutoff`Centrality	Exact Threads	Closeness that only counts vertices within a given distance.
`cmp_epsilon`Spatial graphs and numbers	Unit tests	Compares two doubles with a relative tolerance and returns -1, 0 or 1.
`cocitation`Similarity, transitivity and mixing	Exact	Counts, for pairs of vertices, how many vertices point to both of them.
`cohesion`Flows, cuts and traversal	Exact	Cohesion of a graph, which is its vertex connectivity.
`cohesive_blocks`Flows, cuts and traversal	Exact	Hierarchy of cohesive blocks of an undirected simple graph (Moody and White 2003).
`coloring_greedy_t`Cliques, independent sets and colouring	Unit tests	Which uncoloured vertex `vertex_coloring_greedy` takes next.
`community_eb_get_merges`Community detection	Exact	Builds the dendrogram, bridges, modularity values and best membership from an edge removal order.
`community_edge_betweenness`Community detection	Exact	Girvan-Newman method: removes the edge of highest betweenness again and again and records the dendrogram.
`community_fastgreedy`Community detection	Same quality Partial	Clauset-Newman-Moore greedy modularity optimisation: merges the adjacent pair of communities that raises modularity most, step by step.
`community_fluid_communities`Community detection	Same quality	Fluid communities: k communities spread over the graph like competing fluids until they settle.
`community_infomap`Community detection	Same quality Threads	Infomap: finds the partition that gives the shortest description of a random walk (the map equation).
`community_label_propagation`Community detection	Exact	Label propagation: each vertex repeatedly takes the label that dominates among its neighbours.
`community_leading_eigenvector`Community detection	Within tolerance	Newman's leading eigenvector method: splits communities in two by the signs of the leading eigenvector of their modularity matrix.
`community_leading_eigenvector_callback_t`Community detection	Unit tests	The function type `community_leading_eigenvector` calls after each eigenvector computation.
`community_leiden`Community detection	Exact	Leiden algorithm: optimises a modularity-type quality with explicit vertex weights and guarantees well-connected communities.
`community_leiden_simple`Community detection	Same quality	Leiden algorithm with a named objective (modularity, CPM or Erdos-Renyi) instead of explicit vertex weights.
`community_multilevel`Community detection	Exact	Louvain method: raises modularity by local vertex moves, then collapses communities and repeats.
`community_optimal_modularity`Community detection	Exact	Finds a partition with the largest possible modularity by exact branch and cut.
`community_spinglass`Community detection	Same quality	Spin-glass community detection: simulated annealing of a Potts model whose lowest energy is a generalised modularity optimum.
`community_spinglass_single`Community detection	Unit tests	Finds the community of one vertex by greedy growth under the spin-glass model and reports its cohesion and adhesion.
`community_to_membership`Community detection	Exact	Cuts a dendrogram after a given number of merges and gives the cluster of every leaf.
`community_voronoi`Community detection	Exact	Voronoi communities: picks dense generator vertices and assigns every vertex to its nearest generator.
`community_walktrap`Community detection	Exact	Walktrap: agglomerative clustering by distances between short random walks.
`compare_communities`Community detection	Exact	Measures the distance or similarity of two partitions of the same elements.
`complementer`Operators and bipartite graphs	Exact	Complement graph: the vertex pairs that are not joined.
`complex_almost_equals`Spatial graphs and numbers	Unit tests	Tells whether two complex numbers are equal within a relative tolerance.
`compose`Operators and bipartite graphs	Exact	Relational composition of two graphs.
`connect_neighborhood`Operators and bipartite graphs	Exact	Joins every vertex to all vertices within a given distance, in place.
`connected_components`Components and structure	Exact	Finds the weakly or strongly connected components of a graph.
`constraint`Centrality	Exact	Burt's constraint: how strongly each vertex's contacts are tied to one another.
`contract_vertices`Operators and bipartite graphs	Exact	Merges vertices according to a mapping, in place.
`convergence_degree`Centrality	Exact	Convergence degree of each edge: whether shortest paths funnel into it or fan out from it.
`convex_hull_2d`Spatial graphs and numbers	Exact	Finds the corners of the convex hull of a planar point set, in clockwise order.
`copy`Graph basics	Exact	Duplicates a graph into a new, independent graph object.
`coreness`Components and structure	Exact	Computes the k-core index (shell index) of every vertex.
`correlated_game`Random graphs	Same quality	Draws a random graph correlated with a given simple graph.
`correlated_pair_game`Random graphs	Same quality	Draws two correlated G(n, p) graphs.
`count_adjacent_triangles`Cycles, motifs and epidemics	Exact	Counts, for each selected vertex, the triangles it belongs to.
`count_automorphisms`Isomorphism	Exact	Counts the automorphisms of a graph, optionally keeping vertex colours fixed.
`count_automorphisms_bliss`Isomorphism	Exact	Counts automorphisms exactly, with a chosen heuristic; the group order comes back as a decimal string.
`count_isomorphisms_vf2`Isomorphism	Exact	Counts all isomorphisms between two graphs with VF2.
`count_loops`Components and structure	Exact	Counts the self-loops of a graph.
`count_multiple`Components and structure	Exact	Gives, for each selected edge, how many edges are parallel to it (itself included).
`count_multiple_1`Components and structure	Exact	Gives the multiplicity of a single edge.
`count_reachable`Components and structure	Exact SIMD	Counts, for every vertex, how many vertices it can reach.
`count_subisomorphisms_vf2`Isomorphism	Exact	Counts the occurrences of graph2 as a subgraph of graph1 with VF2.
`count_triangles`Cycles, motifs and epidemics	Exact	Counts the triangles of the graph.
`create`Deterministic generators	Exact	Builds a graph from a flat vector of edge endpoints.
`create_bipartite`Operators and bipartite graphs	Exact	Builds a graph from vertex kinds and an edge list, checking that every edge joins the two kinds.
`cycle_graph`Deterministic generators	Exact	Builds the cycle on n vertices.
`cycle_handler_t`Cycles, motifs and epidemics	Exact	The type of the function `simple_cycles_callback` calls for each cycle.
`de_bruijn`Deterministic generators	Exact	Builds the de Bruijn graph of strings of length n over m letters.
`decompose`Components and structure	Exact	Splits a graph into its connected components, each as a graph of its own.
`degree`Graph basics	Exact	The degrees of a set of vertices.
`degree_1`Graph basics	Exact	Degree of one vertex, returned through a pointer.
`degree_correlation_vector`Similarity, transitivity and mixing	Exact	Computes the mean neighbour degree as a function of a vertex's degree, over all edges.
`degree_sequence_game`Random graphs	Same quality	Draws a random graph with exactly the given degree sequence.
`delaunay_graph`Spatial graphs and numbers	Exact	Builds the Delaunay graph of a point set, in any dimension.
`delete_edges`Graph basics	Exact	Removes the edges an edge selector names.
`delete_vertices`Graph basics	Exact	Removes vertices together with every edge that touches them.
`delete_vertices_map`Graph basics	Unit tests	Removes vertices like `delete_vertices` and reports where every vertex went.
`density`Components and structure	Exact	Computes the density: edges present over edges possible.
`destroy`Graph basics	Unit tests	Frees everything a graph owns.
`dfs`Flows, cuts and traversal	Exact	Depth-first search with discovery and finishing orders and optional callbacks.
`dfshandler_t`Flows, cuts and traversal	Unit tests	Type of the `dfs` callbacks.
`diameter`Paths and distances	Exact Threads	The longest shortest-path length in the graph, with its end points and one path between them.
`difference`Operators and bipartite graphs	Exact	Edges of one graph that are not in another, on shared vertex ids.
`dim_select`Linear algebra and embeddings	Exact	Chooses how many leading values of a decreasing sequence (a scree plot) stand apart from the rest, by Zhu and Ghodsi's profile likelihood.
`disjoint_union`Operators and bipartite graphs	Exact	Puts two graphs side by side in one graph.
`disjoint_union_many`Operators and bipartite graphs	Exact	Puts any number of graphs side by side in one graph.
`distances`Paths and distances	Exact Threads	Shortest-path lengths from a set of source vertices to a set of target vertices, with the algorithm chosen from the weights.
`distances_bellman_ford`Paths and distances	Exact	Shortest-path lengths that allow negative weights, by the Bellman-Ford algorithm.
`distances_cutoff`Paths and distances	Exact Threads	Shortest-path lengths as `distances`, but paths longer than a cutoff are not followed.
`distances_dijkstra`Paths and distances	Exact Threads	Shortest-path lengths with non-negative weights, by Dijkstra's algorithm from each source.
`distances_dijkstra_cutoff`Paths and distances	Exact Threads	Dijkstra shortest-path lengths that stop at a given path length.
`distances_floyd_warshall`Paths and distances	Exact	All-pairs shortest-path lengths by the Floyd-Warshall algorithm, original or tree variant.
`distances_johnson`Paths and distances	Exact Threads	Shortest-path lengths with negative weights, by Johnson's reweighting and one Dijkstra search per source.
`diversity`Components and structure	Exact	Computes the structural diversity of vertices: the evenness of their edge weights.
`dominator_tree`Flows, cuts and traversal	Exact	Immediate dominators of a directed flowgraph, and its dominator tree.
`dot_product_game`Random graphs	Same quality	Draws a graph in which each pair connects with the dot product of the two vertices' latent vectors as its probability.
`dqueue_back`Matrices, stacks, queues and heaps	Unit tests	Returns the last element (the newest) without removing it.
`dqueue_clear`Matrices, stacks, queues and heaps	Unit tests	Empties a double-ended queue but keeps its storage.
`dqueue_destroy`Matrices, stacks, queues and heaps	Unit tests	Frees the storage of a double-ended queue.
`dqueue_empty`Matrices, stacks, queues and heaps	Unit tests	Tells whether a double-ended queue has no elements.
`dqueue_full`Matrices, stacks, queues and heaps	Unit tests	Tells whether the next push will have to grow the storage.
`dqueue_get`Matrices, stacks, queues and heaps	Unit tests	Returns the element at a given position counted from the head.
`dqueue_head`Matrices, stacks, queues and heaps	Unit tests	Returns the first element (the oldest) without removing it.
`dqueue_init`Matrices, stacks, queues and heaps	Unit tests	Creates an empty double-ended queue with room for a given number of elements.
`dqueue_pop`Matrices, stacks, queues and heaps	Unit tests	Removes the head element (the oldest) and returns it.
`dqueue_pop_back`Matrices, stacks, queues and heaps	Unit tests	Removes the back element (the newest) and returns it.
`dqueue_push`Matrices, stacks, queues and heaps	Unit tests	Appends an element at the back of a double-ended queue.
`dqueue_size`Matrices, stacks, queues and heaps	Unit tests	Tells how many elements a double-ended queue holds.
`dqueue_t`Matrices, stacks, queues and heaps	Unit tests	A double-ended queue of real numbers in a ring buffer.
`dyad_census`Cycles, motifs and epidemics	Exact	Counts the mutual, asymmetric and unconnected pairs of vertices.
`ecc`Similarity, transitivity and mixing	Exact	Computes the edge clustering coefficient of selected edges.
`eccentricity`Paths and distances	Exact Threads	Eccentricity of the chosen vertices: the distance to the farthest vertex each one reaches.
`ecount`Graph basics	Exact	How many edges the graph has.
`edge`Graph basics	Unit tests	The two endpoints of one edge.
`edge_betweenness`Centrality	Exact Threads	Edge betweenness: how many shortest paths run along each edge.
`edge_betweenness_cutoff`Centrality	Exact Threads	Edge betweenness counting only shortest paths no longer than a cutoff.
`edge_betweenness_subset`Centrality	Exact Threads	Edge betweenness counting only shortest paths from chosen sources to chosen targets.
`edge_connectivity`Flows, cuts and traversal	Exact	Smallest number of edges whose removal disconnects the graph.
`edge_disjoint_paths`Flows, cuts and traversal	Exact	Largest number of source-target paths that share no edge.
`edge_type_sw_t`Random graphs	Unit tests	Bit switches saying which non-simple edges a function may create.
`edgelist_percolation`Components and structure	Unit tests	Bond percolation on a plain list of vertex pairs, without building a graph.
`edges`Graph basics	Exact	The endpoints of the edges an edge selector names, as one integer vector.
`eigenvector_centrality`Centrality	Within tolerance SIMD	Eigenvector centrality: each score a fixed multiple of the neighbours' summed scores, scaled so the largest is 1.
`eit_create`Graph basics	Unit tests	Resolves an edge selector against a graph into an iterator.
`eit_destroy`Graph basics	Unit tests	Releases any id list an edge iterator built.
`empty`Graph basics	Exact	Makes a graph with n vertices, numbered 0 to n - 1, and no edges.
`empty_attrs`Graph basics	Unit tests	Same as `empty`, and hands a list of graph-attribute records to the attribute handler.
`enter_safelocale`Reading and writing files	Unit tests	Switches the calling thread to the C numeric locale, so that numbers are read and written with a decimal point.
`erdos_renyi_game_gnm`Random graphs	Same quality	Draws a uniformly random graph with n vertices and exactly m edges, G(n, m).
`erdos_renyi_game_gnp`Random graphs	Same quality	Draws a random graph in which every vertex pair is joined independently with probability p, G(n, p).
`error`Graph basics	Unit tests	Hands an error code and message to the current error handler.
`error_handler_abort`Graph basics	Unit tests	The default error handler: prints the error and stops the process.
`error_handler_ignore`Graph basics	Unit tests	Error handler that frees the failing call's temporary objects and lets the error code reach the caller.
`error_handler_printignore`Graph basics	Unit tests	Like `error_handler_ignore`, but prints the error first.
`error_handler_t`Graph basics	Unit tests	Function type for the routine that receives every reported error.
`error_t`Graph basics	Unit tests	The return type of every Open Graph function that can fail.
`error_type_t`Graph basics	Unit tests	The enumeration of Open Graph's error codes.
`errorf`Graph basics	Unit tests	Reports an error with a printf-style message.
`es_1`Graph basics	Unit tests	Selector naming exactly one edge id.
`es_all`Graph basics	Unit tests	Edge selector for every edge, in a chosen order.
`es_all_between`Graph basics	Unit tests	Edge selector for all edges between two vertices.
`es_as_vector`Graph basics	Unit tests	The edge ids a selector resolves to, as a vector.
`es_copy`Graph basics	Unit tests	Copies an edge selector.
`es_destroy`Graph basics	Unit tests	Frees what an edge selector owns.
`es_incident`Graph basics	Unit tests	Edge selector for the edges incident on one vertex.
`es_is_all`Graph basics	Unit tests	Tells whether a selector is the all-edges selector in id order.
`es_none`Graph basics	Unit tests	Selector that resolves to no edge at all.
`es_pairs`Graph basics	Unit tests	Edge selector for the edges between given vertex pairs.
`es_pairs_small`Graph basics	Unit tests	Edge selector for vertex pairs given as int arguments ending in -1.
`es_path`Graph basics	Unit tests	Edge selector for the edges along a vertex path.
`es_range`Graph basics	Unit tests	Edge selector for the ids start, start + 1, ..., end - 1.
`es_size`Graph basics	Unit tests	The number of edges a selector resolves to in a graph.
`es_type`Graph basics	Unit tests	Reports which variant (all, pairs, path, ...) an edge selector is.
`es_vector`Graph basics	Unit tests	Edge selector that borrows the caller's vector of edge ids.
`es_vector_copy`Graph basics	Unit tests	Edge selector that keeps its own copy of a vector of edge ids.
`ess_1`Graph basics	Unit tests	Immediate selector for a single edge.
`ess_all`Graph basics	Unit tests	Immediate selector for every edge, in a chosen order.
`ess_none`Graph basics	Unit tests	Immediate selector for no edges.
`ess_range`Graph basics	Unit tests	Immediate selector for the edge ids start .. end - 1.
`ess_vector`Graph basics	Unit tests	Immediate selector that borrows a vector of edge ids.
`establishment_game`Random graphs	Same quality	Grows a graph in which each new vertex tries k earlier vertices and links by type preference.
`eulerian_cycle`Cycles, motifs and epidemics	Exact	Returns an Eulerian cycle: a closed walk that uses every edge exactly once.
`eulerian_path`Cycles, motifs and epidemics	Exact	Returns an Eulerian path: a walk that uses every edge exactly once.
`even_tarjan_reduction`Cliques, independent sets and colouring	Unit tests	Builds the split directed graph whose maximum flows count vertex-disjoint paths.
`executor_t`Threads	Unit tests Threads Extension	A host's way of running Open Graph's tasks on its own thread pool.
`exit_safelocale`Reading and writing files	Unit tests	Restores the numeric locale that `enter_safelocale` replaced.
`expand_path_to_pairs`Graph basics	Unit tests	Turns a vertex path into the list of its consecutive vertex pairs, in place.
`extended_chordal_ring`Deterministic generators	Exact	Builds an extended chordal ring: a cycle plus chords from a periodic offset table.
`famous`Deterministic generators	Exact	Builds a named graph from a built-in collection of well-known graphs.
`fatal`Graph basics	Unit tests	Stops on an unrecoverable condition through the fatal handler; never returns.
`fatal_handler_abort`Graph basics	Unit tests	The default fatal-error handler: prints the message and aborts.
`fatal_handler_t`Graph basics	Unit tests	Function type for the routine called on unrecoverable internal failures.
`fatalf`Graph basics	Unit tests	Reports a fatal error with a printf-style message; never returns.
`feedback_arc_set`Cycles, motifs and epidemics	Exact Partial	Finds a set of edges whose removal leaves the graph without cycles, exactly or with the Eades heuristic.
`feedback_vertex_set`Cycles, motifs and epidemics	Within tolerance	Finds a minimum-weight set of vertices that meets every cycle.
`find_cycle`Cycles, motifs and epidemics	Unit tests	Returns one cycle of the graph, or two empty vectors when it has none.
`forest_fire_game`Random graphs	Same quality	Grows a graph by the forest fire model.
`free`Graph basics	Unit tests	Frees a block from `malloc`, `calloc` or `realloc`.
`from_hrg_dendrogram`Hierarchical random graphs and progress	Exact	Turns an HRG's dendrogram into a directed tree graph.
`from_prufer`Deterministic generators	Exact	Builds the labelled tree that a Prüfer sequence encodes.
`full`Deterministic generators	Exact	Builds the complete graph on n vertices.
`full_bipartite`Operators and bipartite graphs	Exact	Complete bipartite graph K(n1, n2).
`full_citation`Deterministic generators	Exact	Builds the complete citation graph: every vertex points to all earlier vertices.
`full_multipartite`Deterministic generators	Exact	Builds the complete multipartite graph for given part sizes.
`fundamental_cycles`Cycles, motifs and epidemics	Exact	Returns the cycles closed by the non-tree edges of a breadth-first tree: a cycle basis.
`gabriel_graph`Spatial graphs and numbers	Unit tests	Builds the Gabriel graph: two points are joined when no other point lies in the ball that has them as a diameter.
`generalized_petersen`Deterministic generators	Exact	Builds the generalized Petersen graph GP(n, k).
`get_adjacency`Components and structure	Exact	Builds the dense adjacency matrix of a graph.
`get_adjacency_sparse`Components and structure	Exact	Builds the adjacency matrix of a graph in sparse form.
`get_all_eids_between`Graph basics	Unit tests	Lists the ids of all edges between two vertices, parallel edges included.
`get_all_shortest_paths`Paths and distances	Exact	Every shortest path from one source to the chosen targets, and the number of shortest paths to each vertex.
`get_all_shortest_paths_dijkstra`Paths and distances	Exact	Every shortest path from one source to the chosen targets, with non-negative weights.
`get_all_simple_paths`Paths and distances	Exact	Every simple path (no vertex twice) from a source to the chosen targets.
`get_biadjacency`Operators and bipartite graphs	Exact	Biadjacency matrix of a bipartite graph.
`get_edgelist`Components and structure	Exact	Returns the edges as a flat list of vertex pairs.
`get_eid`Graph basics	Exact	Finds the id of an edge between two vertices.
`get_eids`Graph basics	Exact	Looks up the edge ids for a list of vertex pairs.
`get_executor`Threads	Unit tests Threads Extension	Returns the installed executor, or NULL for Open Graph's own threads.
`get_isomorphisms_vf2`Isomorphism	Exact	Lists every isomorphism between two graphs with VF2.
`get_isomorphisms_vf2_callback`Isomorphism	Exact	Runs the VF2 isomorphism search and calls a function for every mapping found.
`get_k_shortest_paths`Paths and distances	Exact	The k shortest paths without repeated vertices between two vertices, by Yen's algorithm.
`get_laplacian`Similarity, transitivity and mixing	Exact	Builds the Laplacian matrix of a graph, plain or normalized.
`get_laplacian_sparse`Similarity, transitivity and mixing	Exact	Builds the Laplacian matrix in sparse form.
`get_num_procs`Threads	Unit tests Extension	Returns the number of logical processors of the machine.
`get_num_threads`Threads	Unit tests Threads Extension	Returns the number of threads the parallel kernels may use.
`get_shortest_path`Paths and distances	Exact	A shortest route from a given source to a given target.
`get_shortest_path_astar`Paths and distances	Exact	A shortest route from a given source to a given target by A* search, guided by an estimate of the remaining distance.
`get_shortest_path_bellman_ford`Paths and distances	Exact	A shortest route from a given source to a given target, negative weights allowed (Bellman-Ford).
`get_shortest_path_dijkstra`Paths and distances	Exact	A shortest route from a given source to a given target, non-negative weights (Dijkstra).
`get_shortest_paths`Paths and distances	Exact	One shortest path from a source to each target, as vertex lists and edge lists.
`get_shortest_paths_bellman_ford`Paths and distances	Exact	One shortest path from a source to each target, negative weights allowed (Bellman-Ford).
`get_shortest_paths_dijkstra`Paths and distances	Exact	One shortest path from a source to each target with non-negative weights (Dijkstra).
`get_stochastic`Components and structure	Exact	Builds the transition matrix of the random walk on a graph.
`get_stochastic_sparse`Components and structure	Exact	Builds the random-walk transition matrix in sparse form.
`get_subisomorphisms_vf2`Isomorphism	Exact	Lists every occurrence of graph2 as a subgraph of graph1 with VF2.
`get_subisomorphisms_vf2_callback`Isomorphism	Exact	Runs the VF2 subgraph search and calls a function for every match found.
`get_widest_path`Paths and distances	Unit tests	A path between two vertices whose narrowest edge is as wide as possible.
`get_widest_paths`Paths and distances	Unit tests	A widest path from a source to each target, with the tree of widest paths.
`girth`Paths and distances	Exact	Girth: how many edges the shortest cycle has, and one such cycle.
`global_efficiency`Paths and distances	Exact Threads	Mean inverse shortest-path length over all ordered pairs of distinct vertices.
`gomory_hu_tree`Flows, cuts and traversal	Exact	Gomory-Hu tree: a tree holding the minimum cut value of every vertex pair.
`graph_center`Paths and distances	Exact Threads	The vertices of smallest eccentricity.
`graph_count`Isomorphism	Exact	Number of unlabelled graphs on n vertices.
`graph_power`Operators and bipartite graphs	Exact	Graph power: joins every pair of vertices at most k steps apart.
`graphlets`Cycles, motifs and epidemics	Within tolerance	Decomposes a weighted graph into weighted cliques (graphlets).
`graphlets_candidate_basis`Cycles, motifs and epidemics	Exact	Finds the candidate cliques for a graphlet decomposition, each with its threshold.
`graphlets_project`Cycles, motifs and epidemics	Within tolerance	Fits weights to given cliques so that together they explain the edge weights.
`grg_game`Random graphs	Same quality	Draws a random geometric graph: points in the unit square joined when closer than a radius.
`growing_random_game`Random graphs	Same quality	Grows a graph by adding one vertex and m uniformly random edges per step.
`harmonic_centrality`Centrality	Exact Threads	Harmonic centrality: the sum of the inverse distances from each vertex to all others.
`harmonic_centrality_cutoff`Centrality	Exact Threads	Harmonic centrality that only counts vertices within a given distance.
`has_loop`Components and structure	Exact	Tells whether a graph has at least one self-loop.
`has_multiple`Components and structure	Exact	Tells whether a graph has at least one pair of parallel edges.
`has_mutual`Components and structure	Exact	Tells whether a directed graph has at least one pair of opposite edges.
`heap_clear`Matrices, stacks, queues and heaps	Unit tests	Empties a heap but keeps its storage.
`heap_delete_top`Matrices, stacks, queues and heaps	Unit tests	Removes the top element of a heap and returns it.
`heap_destroy`Matrices, stacks, queues and heaps	Unit tests	Frees the storage of a heap.
`heap_empty`Matrices, stacks, queues and heaps	Unit tests	Tells whether a heap has no elements.
`heap_init`Matrices, stacks, queues and heaps	Unit tests	Creates an empty binary heap with room for a given number of elements.
`heap_init_array`Matrices, stacks, queues and heaps	Unit tests	Creates a heap holding a copy of a C array.
`heap_min_t`Matrices, stacks, queues and heaps	Unit tests	A binary minimum heap of real numbers.
`heap_pop`Matrices, stacks, queues and heaps	Unit tests	Removes the top element of a heap and returns it (another name for `heap_delete_top`).
`heap_push`Matrices, stacks, queues and heaps	Unit tests	Adds an element to a heap.
`heap_reserve`Matrices, stacks, queues and heaps	Unit tests	Makes room for at least a given number of elements.
`heap_size`Matrices, stacks, queues and heaps	Unit tests	Tells how many elements a heap holds.
`heap_t`Matrices, stacks, queues and heaps	Unit tests	A binary maximum heap of real numbers.
`heap_top`Matrices, stacks, queues and heaps	Unit tests	Returns the top element (the largest, or the smallest for `heap_min_t`) without removing it.
`hexagonal_lattice`Deterministic generators	Exact	Builds a honeycomb lattice of hexagons in one of three outlines.
`hrg_consensus`Hierarchical random graphs and progress	Same quality	Builds the majority consensus tree of dendrograms sampled in proportion to their likelihood.
`hrg_create`Hierarchical random graphs and progress	Unit tests	Builds an HRG from a directed binary tree graph and per-vertex probabilities.
`hrg_dendrogram`Hierarchical random graphs and progress	Exact	Deprecated: `from_hrg_dendrogram` without the probabilities.
`hrg_destroy`Hierarchical random graphs and progress	Unit tests	Releases the memory of an HRG.
`hrg_fit`Hierarchical random graphs and progress	Same quality	Fits an HRG to a graph by Markov chain Monte Carlo over dendrograms.
`hrg_game`Hierarchical random graphs and progress	Same quality	Draws one random graph from an HRG (`hrg_sample` with the arguments swapped).
`hrg_init`Hierarchical random graphs and progress	Unit tests	Initialises an HRG with room for n vertices, all entries zero.
`hrg_predict`Hierarchical random graphs and progress	Same quality	Scores the unconnected pairs of vertices as possible missing edges.
`hrg_resize`Hierarchical random graphs and progress	Unit tests	Changes the number of leaves of an HRG.
`hrg_sample`Hierarchical random graphs and progress	Same quality	Draws one random graph from an HRG.
`hrg_size`Hierarchical random graphs and progress	Unit tests	Returns the number of vertices (leaves) of an HRG.
`hrg_t`Hierarchical random graphs and progress	Exact	An HRG: a dendrogram with a connection probability at each internal node.
`hsbm_game`Random graphs	Same quality	Draws a hierarchical stochastic block model: equal blocks sharing one internal cluster structure.
`hsbm_list_game`Random graphs	Same quality	Draws a hierarchical stochastic block model whose blocks have their own sizes and cluster structures.
`hub_and_authority_scores`Centrality	Within tolerance SIMD	Hub and authority scores (Kleinberg's HITS) of a directed graph.
`hypercube`Deterministic generators	Exact	Builds the hypercube of dimension n: 2^n vertices, one per n-bit number.
`iea_game`Random graphs	Same quality	Places m edges independently on uniformly random vertex pairs (independent edge assignment).
`incident`Graph basics	Exact	Lists the ids of the edges incident on one vertex.
`inclist_clear`String vectors, lists and bit sets	Unit tests	Empties every vertex's vector and keeps the number of vertices.
`inclist_destroy`String vectors, lists and bit sets	Unit tests	Releases an incidence list with all its vectors.
`inclist_get`String vectors, lists and bit sets	Exact	Gives the incident-edge vector of a vertex in an incidence list.
`inclist_init`String vectors, lists and bit sets	Exact	Builds a list of every vertex's incident edges.
`inclist_size`String vectors, lists and bit sets	Unit tests	Tells how many vertices an incidence list covers.
`independence_number`Cliques, independent sets and colouring	Exact	Independence number: how many vertices a maximum independent set has.
`independent_vertex_sets`Cliques, independent sets and colouring	Exact	Lists every independent vertex set in a size range.
`induced_subgraph`Operators and bipartite graphs	Exact	Subgraph made of the selected vertices and every edge between them.
`induced_subgraph_edges`Operators and bipartite graphs	Exact	Ids of the edges whose two endpoints are both selected.
`induced_subgraph_map`Operators and bipartite graphs	Exact	Induced subgraph, also returning how vertex ids map between the graph and the result.
`intersection`Operators and bipartite graphs	Exact	Intersection of two graphs on shared vertex ids.
`intersection_many`Operators and bipartite graphs	Exact	Intersection of any number of graphs on shared vertex ids.
`invalidate_cache`Graph basics	Unit tests	Forgets every cached whole-graph property.
`invert_permutation`Isomorphism	Unit tests	Computes the inverse of a permutation.
`is_acyclic`Cycles, motifs and epidemics	Exact	Tells whether the graph has no cycle at all, directed or undirected.
`is_biconnected`Components and structure	Exact	Tells whether a graph is biconnected.
`is_bigraphical`Components and structure	Exact	Tells whether two degree sequences can be the sides of a bipartite graph.
`is_bipartite`Operators and bipartite graphs	Exact	Tests whether the vertices split into two kinds with every edge between the kinds, and returns such a split.
`is_bipartite_coloring`Cliques, independent sets and colouring	Unit tests	Checks that a two-colouring puts the ends of every edge on different sides, and tells which way the edges run.
`is_chordal`Components and structure	Exact	Tells whether a graph is chordal, and gives the edges that would make it chordal.
`is_clique`Cliques, independent sets and colouring	Exact	Tests whether the selected vertices are pairwise adjacent.
`is_complete`Cliques, independent sets and colouring	Exact	Tells whether every pair of distinct vertices is joined by an edge.
`is_connected`Components and structure	Exact	Tells whether a graph is weakly or strongly connected.
`is_dag`Cycles, motifs and epidemics	Exact	Tests for a DAG: a directed graph without directed cycles.
`is_directed`Graph basics	Exact	Tells whether a graph is directed.
`is_edge_coloring`Cliques, independent sets and colouring	Unit tests	Checks that edges sharing a vertex have different colours.
`is_eulerian`Cycles, motifs and epidemics	Exact	Tells whether the graph has an Eulerian path and whether it has an Eulerian cycle.
`is_forest`Components and structure	Exact	Tells whether a graph is a forest, and lists one root per tree.
`is_graphical`Components and structure	Exact	Tells whether a degree sequence can be realized by a graph with the allowed edge types.
`is_independent_vertex_set`Cliques, independent sets and colouring	Exact	Tests whether no two of the selected vertices are adjacent.
`is_loop`Components and structure	Exact	Tells, for each selected edge, whether it is a self-loop.
`is_matching`Similarity, transitivity and mixing	Exact	Tells whether a vector describes a valid matching of the graph.
`is_maximal_matching`Similarity, transitivity and mixing	Exact	Tells whether a matching is maximal: no edge could be added to it.
`is_minimal_separator`Cliques, independent sets and colouring	Exact	Tests whether a vertex set separates the graph while no proper subset of it does.
`is_multiple`Components and structure	Exact	Tells, for each selected edge, whether it repeats an earlier parallel edge.
`is_mutual`Components and structure	Exact	Tells, for each selected edge, whether its reverse edge exists too.
`is_perfect`Cliques, independent sets and colouring	Unit tests	Tests whether a simple undirected graph is perfect.
`is_same_graph`Graph basics	Unit tests	Checks whether two graphs have the same directedness, vertex count and edge multiset.
`is_separator`Cliques, independent sets and colouring	Exact	Tests whether removing a vertex set disconnects vertices that were connected.
`is_simple`Components and structure	Exact	Tells whether a graph has no self-loops and no multi-edges.
`is_tree`Components and structure	Exact	Tells whether a graph is a tree, and finds its root.
`is_vertex_coloring`Cliques, independent sets and colouring	Unit tests	Checks that no edge joins two vertices of the same colour.
`isoclass`Isomorphism	Exact	Returns the isomorphism class of a graph with 3 to 6 vertices (undirected) or 3 to 4 vertices (directed).
`isoclass_create`Isomorphism	Exact	Builds a graph of a given isomorphism class.
`isoclass_subgraph`Isomorphism	Exact	Returns the isomorphism class of the subgraph induced by a few chosen vertices.
`isocompat_t`Isomorphism	Unit tests	Type of the compatibility tests the VF2 functions accept for vertex and edge pairs.
`isohandler_t`Isomorphism	Unit tests	Type of the function called by the VF2 searches for every mapping found.
`isomorphic`Isomorphism	Exact	Decides whether two graphs are isomorphic, choosing the method itself.
`isomorphic_bliss`Isomorphism	Exact	Decides isomorphism by canonical labelling and returns a mapping when the graphs are isomorphic.
`isomorphic_vf2`Isomorphism	Exact	Decides isomorphism with VF2, with optional vertex and edge colours and custom compatibility tests, and returns the first mapping.
`jacobian_betweenness_margins`Jacobian	Unit tests Threads Extension	Tells how far each edge weight can move before any betweenness can change.
`jacobian_column`Jacobian	Within tolerance Threads Extension	Returns how every vertex's centrality responds to the weight of one edge.
`jacobian_full`Jacobian	Within tolerance Threads Extension	Returns the whole Jacobian: every vertex's response to every edge weight.
`jacobian_measure_from_name`Jacobian	Exact Extension	Parses a measure name, ignoring case.
`jacobian_measure_name`Jacobian	Exact Extension	Returns the name of a measure.
`jacobian_measure_t`Jacobian	Exact Extension	The centrality measures whose sensitivity to edge weights `og_jacobian_`* compute.
`jacobian_method_t`Jacobian	Exact Extension	How the derivatives are computed: exactly, or by finite differences.
`jacobian_options_init`Jacobian	Exact Extension	Fills an options structure with the defaults.
`jacobian_options_t`Jacobian	Exact Extension	The options of every Jacobian operation: measure, method, step and the measure's own settings.
`jacobian_row`Jacobian	Within tolerance Threads Extension	Returns how one vertex's centrality responds to the weight of every edge.
`jacobian_smoothness`Jacobian	Exact Extension	Returns the smoothness class of a measure.
`jacobian_smoothness_t`Jacobian	Exact Extension	How smoothly a measure depends on the edge weights.
`jacobian_top_k`Jacobian	Within tolerance Threads Extension	Returns the k edges whose weights move one vertex's centrality the most.
`jacobian_warning`Jacobian	Exact Extension	Returns a short warning text for the measures that are not smooth.
`join`Operators and bipartite graphs	Unit tests	Disjoint union of two graphs plus every edge between them.
`joint_degree_distribution`Similarity, transitivity and mixing	Exact	Builds the joint distribution of the degrees at the two ends of the edges.
`joint_degree_matrix`Similarity, transitivity and mixing	Exact	Builds the joint degree matrix: edge counts by the degrees of their two ends.
`joint_type_distribution`Similarity, transitivity and mixing	Exact	Builds the mixing matrix of vertex categories across the edges.
`k_regular_game`Random graphs	Same quality	Draws a random k-regular graph.
`kary_tree`Deterministic generators	Exact	Builds a tree in which every vertex has up to k children, numbered breadth first.
`kautz`Deterministic generators	Exact	Builds the Kautz graph: strings of length n+1 over m+1 letters with no letter repeated in a row.
`lapack_dgeev`Linear algebra and embeddings	Within tolerance SIMD	Computes the eigenvalues and, optionally, the left and right eigenvectors of a general real square matrix.
`lapack_dgeevx`Linear algebra and embeddings	Within tolerance SIMD	`lapack_dgeev` with a choice of balancing, the balancing details and reciprocal condition numbers.
`lapack_dgesv`Linear algebra and embeddings	Within tolerance	Solves the square linear system A X = B by LU factorisation with partial pivoting.
`lapack_dgetrf`Linear algebra and embeddings	Exact	Factors a general m x n matrix as P A = L U by Gaussian elimination with partial pivoting, in place.
`lapack_dgetrs`Linear algebra and embeddings	Within tolerance	Solves A X = B or A^T X = B with the LU factors from `lapack_dgetrf`.
`lapack_dsyevr`Linear algebra and embeddings	Within tolerance SIMD	Eigen-decomposition of a real symmetric matrix: every eigenvalue or a chosen subset, with their eigenvectors when asked for.
`laplacian_normalization_t`Similarity, transitivity and mixing	Exact	Chooses how `get_laplacian`() scales D - A.
`laplacian_spectral_embedding`Linear algebra and embeddings	Within tolerance SIMD	Places the vertices in n dimensions using the leading eigenvectors (undirected) or singular vectors (directed) of a Laplacian of the graph.
`largest_cliques`Cliques, independent sets and colouring	Exact	Finds all cliques of the largest size.
`largest_independent_vertex_sets`Cliques, independent sets and colouring	Exact	Every independent vertex set of maximum size.
`largest_weighted_cliques`Cliques, independent sets and colouring	Unit tests	Finds the cliques of the largest total vertex weight.
`lastcit_game`Random graphs	Same quality	Grows a citation graph in which a vertex's attractiveness depends on how long ago it was last cited.
`layout_align`Layouts	Exact	Centres a layout on the origin and turns it so that its main directions lie along the axes.
`layout_bipartite`Layouts	Same quality	Draws a two-mode graph as two horizontal rows and orders each row to reduce edge crossings.
`layout_circle`Layouts	Exact	Puts the vertices of a selection on the unit circle at equal angles, in the selection's order.
`layout_davidson_harel`Layouts	Same quality	Davidson-Harel layout: simulated annealing on an energy that rewards spread, short edges and few crossings.
`layout_drl`Layouts	Same quality SIMD	DrL force-directed layout for large graphs: a density grid and staged annealing.
`layout_drl_3d`Layouts	Same quality SIMD	DrL force-directed layout in three dimensions.
`layout_drl_default_t`Layouts	Unit tests	Names of the ready-made DrL parameter sets.
`layout_drl_options_init`Layouts	Unit tests	Fills a DrL parameter struct from one of the ready-made sets.
`layout_drl_options_t`Layouts	Unit tests	Parameters of the DrL layout: the edge-cut level and six annealing stages.
`layout_fruchterman_reingold`Layouts	Within tolerance SIMD	Fruchterman-Reingold force-directed layout in 2D: edges attract, all vertex pairs repel, under a falling temperature.
`layout_fruchterman_reingold_3d`Layouts	Within tolerance	Fruchterman-Reingold force-directed layout in 3D.
`layout_gem`Layouts	Same quality	GEM layout (Frick, Ludwig and Mehldau): vertices move one at a time, each with its own temperature.
`layout_graphopt`Layouts	Within tolerance	Force-directed layout after Michael Schmuhl's graphopt: charged vertices repel each other and edges act as springs.
`layout_grid`Layouts	Exact	Places the vertices on a square grid, row after row.
`layout_grid_3d`Layouts	Exact	Places the vertices on a 3D grid, filling layer after layer.
`layout_kamada_kawai`Layouts	Within tolerance Threads SIMD	Kamada-Kawai spring layout: the drawn distance between two vertices follows their graph distance.
`layout_kamada_kawai_3d`Layouts	Within tolerance Threads	Kamada-Kawai spring layout in 3D.
`layout_lgl`Layouts	Same quality	Large Graph Layout: grows the drawing outward from a root, one breadth-first level at a time.
`layout_mds`Layouts	Within tolerance SIMD	Classical multidimensional scaling: drawn distances approximate given or shortest-path distances.
`layout_merge_dla`Layouts	Same quality	Joins several 2D layouts into one, packing them around each other by diffusion-limited aggregation.
`layout_random`Layouts	Same quality	Places every vertex at a uniformly random point of the square [-1, 1] x [-1, 1].
`layout_random_3d`Layouts	Same quality	Places every vertex at a uniformly random point of the cube [-1, 1]^3.
`layout_reingold_tilford`Layouts	Exact Threads	Tidy tree drawing (Reingold-Tilford): one row per level, subtrees packed side by side as tightly as their outlines allow.
`layout_reingold_tilford_circular`Layouts	Exact Threads	The Reingold-Tilford tree drawing bent into a circle: the root in the centre, each level on a ring.
`layout_sphere`Layouts	Exact	Places the vertices on the unit sphere along a spiral from the south pole to the north pole.
`layout_star`Layouts	Exact	Puts one vertex at the origin and the others evenly on the unit circle around it.
`layout_sugiyama`Layouts	Same quality	Layered drawing of a hierarchy (Sugiyama): vertices on horizontal layers, long edges bent through extra points, few crossings.
`layout_umap`Layouts	Same quality	UMAP layout of a neighbour graph: graph neighbours stay close, random pairs are pushed apart.
`layout_umap_3d`Layouts	Same quality	UMAP layout of a neighbour graph in 3D.
`layout_umap_compute_weights`Layouts	Exact	Turns the edge distances of a neighbour graph into UMAP membership weights.
`lazy_adjlist_clear`String vectors, lists and bit sets	Unit tests	Forgets every stored neighbour vector of a lazy adjacency list.
`lazy_adjlist_destroy`String vectors, lists and bit sets	Unit tests	Releases a lazy adjacency list and whatever vectors it stored.
`lazy_adjlist_get`String vectors, lists and bit sets	Exact	Returns a vertex's neighbour vector, reading it from the graph on first use.
`lazy_adjlist_has`String vectors, lists and bit sets	Unit tests	Tells whether a vertex's neighbours have been read already.
`lazy_adjlist_init`String vectors, lists and bit sets	Exact	Sets up an adjacency list that reads a vertex's neighbours only when first asked.
`lazy_adjlist_size`String vectors, lists and bit sets	Unit tests	Tells how many vertices a lazy adjacency list covers.
`lazy_inclist_clear`String vectors, lists and bit sets	Unit tests	Forgets every stored incident-edge vector of a lazy incidence list.
`lazy_inclist_destroy`String vectors, lists and bit sets	Unit tests	Releases a lazy incidence list and whatever vectors it stored.
`lazy_inclist_get`String vectors, lists and bit sets	Exact	Returns a vertex's incident-edge vector, reading it from the graph on first use.
`lazy_inclist_has`String vectors, lists and bit sets	Unit tests	Tells whether a vertex's incident edges have been read already.
`lazy_inclist_init`String vectors, lists and bit sets	Exact	Sets up an incidence list that reads a vertex's incident edges only when first asked.
`lazy_inclist_size`String vectors, lists and bit sets	Unit tests	Tells how many vertices a lazy incidence list covers.
`lcf`Deterministic generators	Exact	Builds a graph from its LCF notation: a Hamiltonian cycle plus chords.
`lcf_small`Deterministic generators	Unit tests	LCF notation with the shifts and the repeat count passed as int arguments.
`le_community_to_membership`Community detection	Unit tests	Cuts the leading eigenvector dendrogram, whose leaves are communities rather than vertices.
`linegraph`Operators and bipartite graphs	Exact	Line graph: one vertex per edge, joined when the edges meet.
`list_triangles`Cycles, motifs and epidemics	Exact	Lists every triangle of the graph, three vertex ids each.
`local_efficiency`Paths and distances	Exact	For each chosen vertex, how well its neighbours reach one another when the vertex is taken out.
`local_scan_0`Centrality	Exact	Scan statistic of order 0: the degree of every vertex, or its strength with weights.
`local_scan_0_them`Centrality	Exact	Order-0 scan statistic of the graph `them`, restricted to the edges the graph `us` has too.
`local_scan_1_ecount`Centrality	Exact	Scan statistic of order 1: the edges (or their weight) among each vertex and its neighbours.
`local_scan_1_ecount_them`Centrality	Exact	Order-1 scan statistic with the neighbourhoods taken from `us` and the edges counted in `them`.
`local_scan_k_ecount`Centrality	Exact	Scan statistic of order k: the edges (or weight) of the subgraph induced by each vertex's k-step neighbourhood.
`local_scan_k_ecount_them`Centrality	Exact	Order-k scan statistic with the neighbourhoods taken from `us` and the edges counted in `them`.
`local_scan_neighborhood_ecount`Centrality	Exact	Edges (or their weight) among given vertex lists, one list per vertex.
`local_scan_subset_ecount`Centrality	Exact	Edges (or their weight) of the subgraph induced by each given vertex subset.
`loops_t`Components and structure	Exact	Tells a function how to count self-loops.
`lune_beta_skeleton`Spatial graphs and numbers	Unit tests	Builds the lune-based beta-skeleton of a point set: A and B are joined when a lune-shaped region built on AB holds no other point.
`malloc`Graph basics	Unit tests	Allocates memory the way Open Graph does.
`MATRIX`Matrices, stacks, queues and heaps	Unit tests	Unchecked access to element (i, j) of any matrix type.
`matrix_add`Matrices, stacks, queues and heaps	Unit tests	Adds a second matrix to the first, element by element.
`matrix_add_cols`Matrices, stacks, queues and heaps	Unit tests	Adds columns of zeros at the right.
`matrix_add_constant`Matrices, stacks, queues and heaps	Unit tests	Increases every element by the same amount.
`matrix_add_rows`Matrices, stacks, queues and heaps	Unit tests	Adds rows of zeros at the bottom.
`matrix_all_almost_e`Matrices, stacks, queues and heaps	Unit tests	Tells whether two real matrices are equal within a relative tolerance.
`matrix_all_e`Matrices, stacks, queues and heaps	Unit tests	Tells whether two matrices have the same shape and equal elements.
`matrix_all_g`Matrices, stacks, queues and heaps	Unit tests	Tells whether every element of the first matrix is larger than the matching element of the second.
`matrix_all_ge`Matrices, stacks, queues and heaps	Unit tests	Tells whether every element of the first matrix is at least the matching element of the second.
`matrix_all_l`Matrices, stacks, queues and heaps	Unit tests	Tells whether every element of the first matrix is smaller than the matching element of the second.
`matrix_all_le`Matrices, stacks, queues and heaps	Unit tests	Tells whether every element of the first matrix is at most the matching element of the second.
`matrix_as_sparsemat`Sparse matrices	Unit tests	Converts a dense matrix into a sparse matrix, dropping elements close to zero.
`matrix_capacity`Matrices, stacks, queues and heaps	Unit tests	Returns how many elements the storage has room for.
`matrix_cbind`Matrices, stacks, queues and heaps	Unit tests	Appends the columns of one matrix to the right of another.
`matrix_colsum`Matrices, stacks, queues and heaps	Unit tests	Computes the sum of each column.
`matrix_complex_all_almost_e`Matrices, stacks, queues and heaps	Unit tests	Tells whether two complex matrices are equal within a relative tolerance.
`matrix_complex_create`Matrices, stacks, queues and heaps	Unit tests	Builds a complex matrix from two real matrices: real parts and imaginary parts.
`matrix_complex_create_polar`Matrices, stacks, queues and heaps	Unit tests	Builds a complex matrix from moduli and angles in radians.
`matrix_complex_imag`Matrices, stacks, queues and heaps	Unit tests	Copies the imaginary parts of a complex matrix into a real matrix.
`matrix_complex_real`Matrices, stacks, queues and heaps	Unit tests	Copies the real parts of a complex matrix into a real matrix.
`matrix_complex_realimag`Matrices, stacks, queues and heaps	Unit tests	Copies the real and the imaginary parts of a complex matrix into two real matrices.
`matrix_complex_zapsmall`Matrices, stacks, queues and heaps	Unit tests	Sets the real or imaginary parts that are very close to zero to exactly zero.
`matrix_contains`Matrices, stacks, queues and heaps	Unit tests	Tells whether a value occurs in a matrix.
`matrix_copy_to`Matrices, stacks, queues and heaps	Unit tests	Copies the elements of a matrix into a plain C array, row by row or column by column.
`matrix_destroy`Matrices, stacks, queues and heaps	Unit tests	Frees the storage of a matrix.
`matrix_div_elements`Matrices, stacks, queues and heaps	Unit tests	Divides a matrix by another, element by element.
`matrix_empty`Matrices, stacks, queues and heaps	Unit tests	Tells whether a matrix has no elements.
`matrix_fill`Matrices, stacks, queues and heaps	Unit tests	Sets every element to the same value.
`matrix_get`Matrices, stacks, queues and heaps	Unit tests	Returns element (row, col).
`matrix_get_col`Matrices, stacks, queues and heaps	Unit tests	Copies one column of a matrix into a vector.
`matrix_get_ptr`Matrices, stacks, queues and heaps	Unit tests	Returns a pointer to element (row, col).
`matrix_get_row`Matrices, stacks, queues and heaps	Unit tests	Copies one row of a matrix into a vector.
`matrix_init`Matrices, stacks, queues and heaps	Unit tests	Creates an nrow by ncol matrix with every element zero.
`matrix_init_array`Matrices, stacks, queues and heaps	Unit tests	Creates a matrix from a plain C array given row by row or column by column.
`matrix_init_copy`Matrices, stacks, queues and heaps	Unit tests	Creates a new matrix holding a copy of another.
`MATRIX_INIT_FINALLY`Matrices, stacks, queues and heaps	Unit tests	Initialises a matrix and registers it on the cleanup stack in one step.
`matrix_is_symmetric`Matrices, stacks, queues and heaps	Unit tests	Tells whether a matrix is square and equal to its transpose.
`matrix_isnull`Matrices, stacks, queues and heaps	Unit tests	Tells whether every element is zero.
`matrix_max`Matrices, stacks, queues and heaps	Unit tests	Returns the largest element.
`matrix_maxdifference`Matrices, stacks, queues and heaps	Unit tests	Returns the largest absolute difference between matching elements of two matrices.
`matrix_min`Matrices, stacks, queues and heaps	Unit tests	Returns the smallest element.
`matrix_minmax`Matrices, stacks, queues and heaps	Unit tests	Returns the smallest and the largest element in one pass.
`matrix_mul_elements`Matrices, stacks, queues and heaps	Unit tests	Multiplies two matrices element by element.
`matrix_ncol`Matrices, stacks, queues and heaps	Unit tests	Returns the number of columns.
`matrix_nrow`Matrices, stacks, queues and heaps	Unit tests	Returns the number of rows.
`matrix_null`Matrices, stacks, queues and heaps	Unit tests	Sets every element to zero.
`matrix_prod`Matrices, stacks, queues and heaps	Unit tests	Returns the product of all elements.
`matrix_rbind`Matrices, stacks, queues and heaps	Unit tests	Appends the rows of one matrix below another.
`matrix_remove_col`Matrices, stacks, queues and heaps	Unit tests	Deletes one column.
`matrix_remove_row`Matrices, stacks, queues and heaps	Unit tests	Deletes one row.
`matrix_resize`Matrices, stacks, queues and heaps	Unit tests	Changes the shape of a matrix.
`matrix_resize_min`Matrices, stacks, queues and heaps	Unit tests	Gives back the spare storage, so that the capacity equals the number of elements.
`matrix_rowsum`Matrices, stacks, queues and heaps	Unit tests	Computes the sum of each row.
`matrix_scale`Matrices, stacks, queues and heaps	Unit tests	Scales every element by the same factor.
`matrix_search`Matrices, stacks, queues and heaps	Unit tests	Finds the next occurrence of a value, scanning from a position in storage order.
`matrix_select_cols`Matrices, stacks, queues and heaps	Unit tests	Builds a matrix from chosen columns of another, in the order given.
`matrix_select_rows`Matrices, stacks, queues and heaps	Unit tests	Builds a matrix from chosen rows of another, in the order given.
`matrix_select_rows_cols`Matrices, stacks, queues and heaps	Unit tests	Builds a matrix from chosen rows and columns of another.
`matrix_set`Matrices, stacks, queues and heaps	Unit tests	Sets element (row, col) to a value.
`matrix_set_col`Matrices, stacks, queues and heaps	Unit tests	Overwrites one column with the elements of a vector.
`matrix_set_row`Matrices, stacks, queues and heaps	Unit tests	Overwrites one row with the elements of a vector.
`matrix_size`Matrices, stacks, queues and heaps	Unit tests	Returns the number of elements, nrow * ncol.
`matrix_storage_t`Matrices, stacks, queues and heaps	Unit tests	How a plain C array lays out a matrix: by rows or by columns.
`matrix_sub`Matrices, stacks, queues and heaps	Unit tests	Subtracts a second matrix from the first, element by element.
`matrix_sum`Matrices, stacks, queues and heaps	Unit tests	Returns the sum of all elements.
`matrix_swap`Matrices, stacks, queues and heaps	Unit tests	Exchanges the contents of two matrices.
`matrix_swap_cols`Matrices, stacks, queues and heaps	Unit tests	Exchanges two columns in place.
`matrix_swap_rows`Matrices, stacks, queues and heaps	Unit tests	Exchanges two rows in place.
`matrix_t`Matrices, stacks, queues and heaps	Unit tests	A dense matrix of real numbers, stored column by column.
`matrix_transpose`Matrices, stacks, queues and heaps	Unit tests	Transposes a matrix in place.
`matrix_update`Matrices, stacks, queues and heaps	Unit tests	Makes an existing matrix an exact copy of another.
`matrix_view`Matrices, stacks, queues and heaps	Unit tests	Wraps an existing column-major C array as a matrix, without copying.
`matrix_view_from_vector`Matrices, stacks, queues and heaps	Unit tests	Wraps the elements of a vector as a matrix with a given number of rows, without copying.
`matrix_which_max`Matrices, stacks, queues and heaps	Unit tests	Finds the row and column of the largest element.
`matrix_which_min`Matrices, stacks, queues and heaps	Unit tests	Finds the row and column of the smallest element.
`matrix_which_minmax`Matrices, stacks, queues and heaps	Unit tests	Finds the positions of the smallest and the largest element in one pass.
`matrix_zapsmall`Matrices, stacks, queues and heaps	Unit tests	Sets the elements that are very close to zero to exactly zero.
`maxdegree`Centrality	Exact	The largest degree among the chosen vertices.
`maxflow`Flows, cuts and traversal	Exact	Maximum flow from a source to a target, with the flow on every edge and a minimum cut.
`maxflow_stats_t`Flows, cuts and traversal	Unit tests	Operation counts of the push-relabel solver.
`maxflow_value`Flows, cuts and traversal	Exact	Value of a maximum flow between two vertices.
`maximal_cliques`Cliques, independent sets and colouring	Exact	Lists the cliques that no further vertex can join.
`maximal_cliques_callback`Cliques, independent sets and colouring	Exact	Passes every maximal clique in a size range to a function instead of storing it.
`maximal_cliques_count`Cliques, independent sets and colouring	Exact	Counts the maximal cliques in a size range without listing them.
`maximal_cliques_file`Cliques, independent sets and colouring	Exact	Writes the maximal cliques to an open file, one per line.
`maximal_cliques_hist`Cliques, independent sets and colouring	Exact	Histogram of maximal clique sizes.
`maximal_cliques_subset`Cliques, independent sets and colouring	Unit tests	Runs the maximal clique search from chosen start vertices only.
`maximal_independent_vertex_sets`Cliques, independent sets and colouring	Exact	Lists the independent vertex sets that no further vertex can join.
`maximum_bipartite_matching`Similarity, transitivity and mixing	Within tolerance	Finds a maximum matching, or a maximum-weight matching, of a bipartite graph.
`maximum_cardinality_search`Components and structure	Exact	Orders the vertices by maximum cardinality search, the first step of a chordality test.
`mean_degree`Components and structure	Exact	Computes the average degree of the vertices.
`metric_t`Spatial graphs and numbers	Unit tests	Selects the distance used by the spatial functions: Euclidean or Manhattan.
`mincut`Flows, cuts and traversal	Exact	Minimum edge cut of the whole graph.
`mincut_value`Flows, cuts and traversal	Exact	Total capacity of a minimum edge cut of the whole graph.
`minimum_cycle_basis`Cycles, motifs and epidemics	Exact	Returns a cycle basis of the smallest total length (lengths in edges).
`minimum_size_separators`Cliques, independent sets and colouring	Exact	Lists every vertex separator of the smallest possible size.
`minimum_spanning_tree`Components and structure	Exact	Finds a minimum spanning forest and returns its edge ids.
`modularity`Community detection	Exact	Computes the modularity of a partition of the vertices, with optional weights, resolution and directed form.
`modularity_matrix`Community detection	Exact	Builds the modularity matrix: the adjacency matrix minus the null model's expected edge weights.
`motifs_handler_t`Cycles, motifs and epidemics	Exact	The type of the function `motifs_randesu_callback` calls for each motif.
`motifs_randesu`Cycles, motifs and epidemics	Exact Threads	Counts the motifs (connected induced subgraphs) of a given size in each isomorphism class.
`motifs_randesu_callback`Cycles, motifs and epidemics	Exact	Hands every motif found, with its vertices and its isomorphism class, to a handler.
`motifs_randesu_estimate`Cycles, motifs and epidemics	Exact Threads	Estimates the number of connected subgraphs of a given size from a sample of start vertices.
`motifs_randesu_no`Cycles, motifs and epidemics	Exact Threads	Counts all connected induced subgraphs of a given size, without classifying them.
`mycielski_graph`Deterministic generators	Exact	Builds Mycielski's triangle-free graph M_k, whose chromatic number is k.
`mycielskian`Operators and bipartite graphs	Exact	Applies the Mycielski construction k times.
`nearest_neighbor_graph`Spatial graphs and numbers	Exact	Joins every point to its k nearest neighbours, optionally only those closer than a cutoff.
`neighborhood`Paths and distances	Exact	The vertices within a given number of steps of each chosen vertex.
`neighborhood_graphs`Paths and distances	Unit tests	The subgraph induced by each chosen vertex's neighbourhood.
`neighborhood_size`Paths and distances	Exact	How many vertices lie within a given number of steps of each chosen vertex.
`neighbors`Graph basics	Exact	Lists the neighbours of one vertex.
`neimode_t`Components and structure	Exact	Chooses which edges of a directed graph a function follows.
`pagerank`Centrality	Within tolerance	PageRank scores of the vertices (Brin and Page), summing to 1.
`pagerank_algo_t`Centrality	Unit tests	Names the PageRank solver; in Open Graph both values give the same scores.
`path_graph`Deterministic generators	Exact	Builds the path on n vertices.
`path_length_hist`Paths and distances	Exact Threads	Histogram of the unweighted shortest-path lengths between connected pairs.
`permute_vertices`Isomorphism	Exact	Relabels the vertices of a graph.
`personalized_pagerank`Centrality	Within tolerance	PageRank in which the random jumps follow a given distribution.
`personalized_pagerank_vs`Centrality	Within tolerance	PageRank in which the random jumps go to a chosen set of vertices.
`plfit_result_calculate_p_value`Spatial graphs and numbers	Same quality	Estimates the p-value of a power-law fit by a semi-parametric bootstrap.
`plfit_result_t`Spatial graphs and numbers	Unit tests	The result of `power_law_fit`: the fitted power law and how well it fits.
`power_law_fit`Spatial graphs and numbers	Within tolerance	Fits a power-law distribution to samples by maximum likelihood, choosing the lower cutoff xmin by the Kolmogorov-Smirnov distance.
`preference_game`Random graphs	Same quality	Draws a graph whose vertices get random types and connect with a type-dependent probability.
`product`Operators and bipartite graphs	Exact	Cartesian, lexicographic, strong, tensor or modular product of two graphs.
`product_t`Operators and bipartite graphs	Unit tests	The graph products of `product`.
`progress`Hierarchical random graphs and progress	Unit tests	Reports progress to the calling thread's progress handler.
`progress_handler_stderr`Hierarchical random graphs and progress	Unit tests	A ready-made progress handler that prints to stderr.
`progress_handler_t`Hierarchical random graphs and progress	Unit tests	The type of a function that receives progress reports from long computations.
`progressf`Hierarchical random graphs and progress	Unit tests	Reports progress with a printf-style message.
`pseudo_diameter`Paths and distances	Unit tests	A quick lower bound of the diameter from repeated farthest-vertex sweeps.
`psumtree_destroy`String vectors, lists and bit sets	Unit tests	Frees a prefix sum tree.
`psumtree_get`String vectors, lists and bit sets	Unit tests	Returns the value of one item.
`psumtree_init`String vectors, lists and bit sets	Unit tests	Creates a prefix sum tree over `size` items, all with value zero.
`psumtree_reset`String vectors, lists and bit sets	Unit tests	Sets every value of a prefix sum tree to zero.
`psumtree_search`String vectors, lists and bit sets	Unit tests	Maps a number in [0, total) to the item whose share of the running total contains it.
`psumtree_size`String vectors, lists and bit sets	Unit tests	Tells how many items a prefix sum tree holds.
`psumtree_sum`String vectors, lists and bit sets	Unit tests	Returns the total of all item values.
`psumtree_update`String vectors, lists and bit sets	Unit tests	Gives one item a new value and refreshes the sums above it.
`radius`Paths and distances	Exact Threads	The smallest eccentricity in the graph.
`random_sample`Spatial graphs and numbers	Same quality	Draws length distinct integers from the range [l, h], uniformly at random, in increasing order.
`random_spanning_tree`Components and structure	Same quality	Draws a spanning tree uniformly at random.
`random_walk`Flows, cuts and traversal	Same quality	Random walk of a given number of steps from a start vertex.
`random_walk_stuck_t`Flows, cuts and traversal	Unit tests	What `random_walk` does at a vertex it cannot leave.
`reachability`Components and structure	Exact SIMD	Computes, for every component, the set of vertices it can reach, as bitsets.
`read_graph_dimacs_flow`Reading and writing files	Exact	Reads a DIMACS network-flow file: a maximum-flow problem with source, target and capacities, or an edge problem with vertex labels.
`read_graph_dl`Reading and writing files	Exact	Reads a UCINET DL file in full-matrix, edge-list or node-list form.
`read_graph_edgelist`Reading and writing files	Exact	Builds a graph from a text stream of whitespace-separated vertex id pairs.
`read_graph_gml`Reading and writing files	Exact	Reads the first graph of a GML file, with its simple-valued attributes.
`read_graph_graphdb`Reading and writing files	Exact	Reads a graph in the binary format of the graph database of De Santo, Foggia, Sansone and Vento (2003).
`read_graph_graphml`Reading and writing files	Exact	Reads one graph of a GraphML document, with its graph, vertex and edge attributes.
`read_graph_lgl`Reading and writing files	Exact	Reads the LGL format, where a "# name" line opens a block that lists that vertex's neighbours.
`read_graph_ncol`Reading and writing files	Exact	Reads a named edge list in the NCOL format of the LGL package: one "name name [weight]" line per edge.
`read_graph_pajek`Reading and writing files	Exact	Reads a Pajek .net file, including two-mode networks, vertex coordinates and drawing parameters.
`realize_bipartite_degree_sequence`Deterministic generators	Exact	Builds one bipartite graph with exactly the given degrees on its two sides.
`realize_degree_sequence`Deterministic generators	Exact	Builds one graph with exactly the given degrees, by a deterministic greedy construction.
`realloc`Graph basics	Unit tests	Changes the size of a block from `malloc`, `calloc` or `realloc`.
`recent_degree_aging_game`Random graphs	Same quality	Grows a graph by recent-degree attachment combined with aging.
`recent_degree_game`Random graphs	Same quality	Grows a graph by attachment to vertices that gained many edges recently.
`reciprocity`Components and structure	Exact	Measures how often directed edges are returned.
`regular_tree`Deterministic generators	Unit tests	Builds a tree of height h whose inner vertices all have degree k (a finite Bethe lattice).
`reindex_membership`Community detection	Exact	Renumbers community ids to 0, 1, 2, ... in order of first appearance.
`relative_neighborhood_graph`Spatial graphs and numbers	Unit tests	Builds the relative neighbourhood graph: two points are joined unless a third point is closer to both of them than they are to each other.
`reverse_edges`Operators and bipartite graphs	Exact	Reverses the direction of the selected edges, in place.
`rewire`Random graphs	Same quality	Randomly rewires a graph in place while keeping every vertex's degree.
`rewire_directed_edges`Random graphs	Same quality	Moves one chosen endpoint of each directed edge to a random vertex with a given probability, in place.
`rewire_edges`Random graphs	Same quality	Moves edge endpoints to uniformly random vertices with a given probability, in place.
`rich_club_sequence`Similarity, transitivity and mixing	Exact	Gives the edge count or density of what is left as vertices are removed one by one.
`ring`Deterministic generators	Exact	Builds a path or a cycle on n vertices.
`rng_bits`Graph basics	Unit tests	How many bits one raw draw of the generator holds.
`rng_default`Graph basics	Unit tests	Returns the generator that randomised functions use on this thread.
`rng_destroy`Graph basics	Unit tests	Frees a generator's state.
`rng_get_binom`Graph basics	Same quality	A binomial random count: successes in n independent trials of probability p.
`rng_get_bool`Graph basics	Same quality	A random true or false, each with probability one half.
`rng_get_exp`Graph basics	Same quality	An exponentially distributed random real with the given rate.
`rng_get_gamma`Graph basics	Same quality	A gamma-distributed random real with the given shape and scale.
`rng_get_geom`Graph basics	Same quality	A geometric random count: failures before the first success, with success probability p.
`rng_get_integer`Graph basics	Exact	A uniform random integer between l and h, both included.
`rng_get_normal`Graph basics	Same quality	A normally distributed random real with mean m and standard deviation s.
`rng_get_pois`Graph basics	Same quality	A Poisson random count with the given mean.
`rng_get_unif`Graph basics	Same quality	A uniform random real in [l, h).
`rng_get_unif01`Graph basics	Same quality	A uniform random real in [0, 1).
`rng_init`Graph basics	Unit tests	Creates a generator of a given type.
`rng_max`Graph basics	Unit tests	The largest raw value the generator produces.
`rng_name`Graph basics	Unit tests	The name of the generator's type.
`rng_sample_dirichlet`Spatial graphs and numbers	Same quality	Draws n samples from the Dirichlet distribution with parameter vector alpha.
`rng_sample_sphere_surface`Spatial graphs and numbers	Same quality	Draws points uniformly on the surface of a sphere centred at the origin, in any dimension.
`rng_sample_sphere_volume`Spatial graphs and numbers	Same quality	Draws points uniformly inside a ball centred at the origin, in any dimension.
`rng_seed`Graph basics	Unit tests	Restarts a generator's stream from a given seed value.
`rng_set_default`Graph basics	Unit tests	Makes another generator the calling thread's default.
`rngtype_glibc2`Graph basics	Exact	Generator type: the additive feedback generator behind glibc's random(), 31 bits per draw.
`rngtype_mt19937`Graph basics	Exact	Generator type: the Mersenne Twister MT19937, 32 bits per draw.
`rngtype_pcg32`Graph basics	Exact	Generator type: PCG32 (XSH-RR 64/32), the default generator.
`rngtype_pcg64`Graph basics	Exact	Generator type: PCG64 (XSL-RR 128/64), 64 bits per draw.
`rollup`Rollup	Within tolerance Threads Extension	Multiplies along every path from the starts and adds the paths up: bills of materials, ownership through chains, reciprocal allocation, Leontief input-output.
`ROLLUP_IN_LOOP`Rollup	Exact Extension	The level `rollup` gives a vertex inside a solved loop.
`rollup_info_t`Rollup	Exact Extension	What `rollup` found on its way, also when it stops with an error.
`rollup_loops_t`Rollup	Exact Extension	What `rollup` does when the links it follows loop back.
`rollup_options_init`Rollup	Exact Extension	Fills the rollup's options with their defaults.
`rollup_options_t`Rollup	Exact Extension	The choices `rollup` takes.
`rooted_product`Operators and bipartite graphs	Exact	Rooted product: a copy of g2 hung on every vertex of g1 by its root.
`roots_for_tree_layout`Layouts	Exact Threads	Chooses one root per component for a tree layout.
`running_mean`Spatial graphs and numbers	Exact	Computes the mean of every window of binwidth consecutive values.
`sbm_game`Random graphs	Same quality	Draws a random graph with block structure: blocks of consecutive vertices and one connection probability per block pair (stochastic block model).
`set_attribute_table`Attributes	Unit tests	Attaches an attribute handler for the whole process and returns the previous one.
`set_error_handler`Graph basics	Unit tests	Installs the process-wide error handler.
`set_executor`Threads	Unit tests Threads Extension	Lends a host's thread pool to Open Graph, or restores Open Graph's own threads.
`set_fatal_handler`Graph basics	Unit tests	Replaces the routine `fatal` calls, for the whole process.
`set_num_threads`Threads	Unit tests Threads Extension	Sets how many threads Open Graph's parallel kernels may use, process-wide.
`set_progress_handler`Hierarchical random graphs and progress	Unit tests	Installs a progress handler for the calling thread, or removes it.
`set_status_handler`Hierarchical random graphs and progress	Unit tests	Installs a status handler for the calling thread, or removes it.
`set_warning_handler`Graph basics	Unit tests	Chooses which routine receives warnings, for the whole process.
`setup`Graph basics	Unit tests	Optional start-up call that reseeds the calling thread's default random number generator from the clock.
`simd_features`SIMD	Unit tests SIMD Extension	Reports what the CPU detection saw and which path it chose.
`simd_path`SIMD	Unit tests SIMD Extension	Returns the name of the vector-instruction path Open Graph's kernels run on.
`similarity_dice`Similarity, transitivity and mixing	Exact Threads SIMD	Computes the Dice similarity of the neighbourhoods of two sets of vertices.
`similarity_dice_es`Similarity, transitivity and mixing	Exact Threads	Computes the Dice similarity of the two endpoints of each selected edge.
`similarity_dice_pairs`Similarity, transitivity and mixing	Exact Threads	Computes the Dice similarity for a list of vertex pairs.
`similarity_inverse_log_weighted`Similarity, transitivity and mixing	Exact	Adamic-Adar similarity: shared neighbours, each weighted by one over the log of its degree.
`similarity_jaccard`Similarity, transitivity and mixing	Exact Threads SIMD	Computes the Jaccard similarity of the neighbourhoods of two sets of vertices.
`similarity_jaccard_es`Similarity, transitivity and mixing	Exact Threads	Computes the Jaccard similarity of the two endpoints of each selected edge.
`similarity_jaccard_pairs`Similarity, transitivity and mixing	Exact Threads	Computes the Jaccard similarity for a list of vertex pairs.
`simple_cycles`Cycles, motifs and epidemics	Exact	Lists every simple cycle of the graph, as vertex lists, edge lists or both.
`simple_cycles_callback`Cycles, motifs and epidemics	Exact	Calls a function for every simple cycle instead of collecting them.
`simple_interconnected_islands_game`Random graphs	Same quality	Draws a graph of equal random islands joined by a few random edges.
`simplify`Operators and bipartite graphs	Exact	Removes parallel edges, self-loops or both, in place.
`simplify_and_colorize`Isomorphism	Exact	Turns a multigraph into a simple graph whose colours record the self-loops and edge multiplicities.
`sir`Cycles, motifs and epidemics	Same quality	Simulates the SIR epidemic model on the graph, no_sim times.
`sir_destroy`Cycles, motifs and epidemics	Unit tests	Releases the four vectors of one `sir_t`.
`sir_t`Cycles, motifs and epidemics	Exact	One simulated SIR epidemic: event times and compartment sizes.
`site_percolation`Components and structure	Unit tests	Adds vertices one by one and records the size of the largest component after each.
`small`Deterministic generators	Unit tests	Builds a small graph from endpoints passed directly as int arguments.
`spanner`Components and structure	Same quality	Picks a sparse subset of edges that keeps every distance within a stretch factor.
`sparse_adjacency`Deterministic generators	Unit tests	Turns a sparse matrix of edge counts into a graph.
`sparse_weighted_adjacency`Deterministic generators	Unit tests	Builds a weighted graph from a sparse matrix, one edge per non-zero entry.
`sparsemat_add`Sparse matrices	Within tolerance	Computes the linear combination alpha A + beta B of two sparse matrices.
`sparsemat_add_cols`Sparse matrices	Unit tests	Adds empty columns at the right of a sparse matrix.
`sparsemat_add_rows`Sparse matrices	Unit tests	Adds empty rows at the bottom of a sparse matrix.
`sparsemat_arpack_rnsolve`Sparse matrices	Within tolerance	Finds selected eigenpairs of a general, non-symmetric sparse matrix.
`sparsemat_arpack_rssolve`Sparse matrices	Within tolerance	Finds selected eigenpairs of a symmetric sparse matrix.
`sparsemat_as_matrix`Sparse matrices	Within tolerance	Expands a sparse matrix into an ordinary dense `matrix_t`.
`sparsemat_cholsol`Sparse matrices	Within tolerance	Solves A x = b for a symmetric positive definite sparse matrix by Cholesky decomposition.
`sparsemat_colsums`Sparse matrices	Within tolerance	Computes the sum of each column of a sparse matrix.
`sparsemat_compress`Sparse matrices	Exact	Builds the column-compressed form of a triplet sparse matrix.
`sparsemat_count_nonzero`Sparse matrices	Exact	Counts the stored elements that are not zero.
`sparsemat_count_nonzerotol`Sparse matrices	Exact	Counts the stored elements whose magnitude is above a tolerance.
`sparsemat_destroy`Sparse matrices	Unit tests	Frees the storage of a sparse matrix.
`sparsemat_droptol`Sparse matrices	Exact	Removes the elements whose magnitude is at most a tolerance.
`sparsemat_dropzeros`Sparse matrices	Exact	Removes the elements that are exactly zero.
`sparsemat_dupl`Sparse matrices	Exact	Sums the pieces stored for the same position of a column-compressed matrix.
`sparsemat_entry`Sparse matrices	Unit tests	Adds one entry to a sparse matrix in triplet form.
`sparsemat_fkeep`Sparse matrices	Unit tests	Keeps only the stored entries a callback function accepts.
`sparsemat_gaxpy`Sparse matrices	Within tolerance	Adds the product of a sparse matrix and a vector to a vector: res = res + A x.
`sparsemat_get`Sparse matrices	Within tolerance	Returns element (row, col) of a sparse matrix.
`sparsemat_getelements`Sparse matrices	Exact	Copies the stored entries of a sparse matrix into three vectors.
`sparsemat_getelements_sorted`Sparse matrices	Exact	Copies the stored entries into three vectors, ordered by column and then by row.
`sparsemat_index`Sparse matrices	Within tolerance	Extracts a submatrix with chosen rows and columns.
`sparsemat_init`Sparse matrices	Unit tests	Creates an empty sparse matrix in triplet form, ready for entries.
`sparsemat_init_copy`Sparse matrices	Unit tests	Creates a new sparse matrix holding a copy of another.
`sparsemat_init_diag`Sparse matrices	Unit tests	Creates a square diagonal sparse matrix from a vector of diagonal values.
`sparsemat_init_eye`Sparse matrices	Unit tests	Creates an n by n sparse matrix with the same value on every diagonal position.
`SPARSEMAT_INIT_FINALLY`Sparse matrices	Unit tests	Initialises a sparse matrix and registers it on the cleanup stack in one step.
`sparsemat_is_cc`Sparse matrices	Exact	True when a sparse matrix uses the column-compressed layout.
`sparsemat_is_symmetric`Sparse matrices	Exact	Tells whether a sparse matrix is square and equal to its transpose.
`sparsemat_is_triplet`Sparse matrices	Exact	True when a sparse matrix uses the triplet layout.
`sparsemat_iterator_col`Sparse matrices	Unit tests	Column index of the entry the iterator points at.
`sparsemat_iterator_end`Sparse matrices	Unit tests	Tells whether an iterator has passed the last stored entry.
`sparsemat_iterator_get`Sparse matrices	Unit tests	Stored value of the entry the iterator points at.
`sparsemat_iterator_idx`Sparse matrices	Unit tests	Returns the position of the iterator's current entry in the storage arrays.
`sparsemat_iterator_init`Sparse matrices	Unit tests	Starts an iterator over the stored entries of a sparse matrix.
`sparsemat_iterator_next`Sparse matrices	Unit tests	Advances an iterator to the next stored entry.
`sparsemat_iterator_reset`Sparse matrices	Unit tests	Moves an iterator back to the first stored entry.
`sparsemat_iterator_row`Sparse matrices	Unit tests	Row index of the entry the iterator points at.
`sparsemat_iterator_t`Sparse matrices	Unit tests	An iterator over the stored entries of a sparse matrix.
`sparsemat_lsolve`Sparse matrices	Within tolerance	Solves L x = b for a lower triangular sparse matrix L.
`sparsemat_ltsolve`Sparse matrices	Within tolerance	Solves L' x = b for a lower triangular sparse matrix L (using its transpose).
`sparsemat_lu`Sparse matrices	Within tolerance	Computes the LU decomposition P A Q = L U of a square sparse matrix.
`sparsemat_luresol`Sparse matrices	Within tolerance	Solves A x = b with an LU decomposition computed earlier.
`sparsemat_lusol`Sparse matrices	Within tolerance	Solves A x = b for a square sparse matrix by LU decomposition.
`sparsemat_max`Sparse matrices	Exact	Returns the largest stored element of a sparse matrix.
`sparsemat_min`Sparse matrices	Exact	Returns the smallest stored element of a sparse matrix.
`sparsemat_minmax`Sparse matrices	Exact	Returns the smallest and the largest stored element in one pass.
`sparsemat_multiply`Sparse matrices	Within tolerance	Computes the matrix product A B of two sparse matrices.
`sparsemat_ncol`Sparse matrices	Exact	Returns the number of columns of a sparse matrix.
`sparsemat_nonzero_storage`Sparse matrices	Exact	Counts the stored entries, pieces and explicit zeros included.
`sparsemat_nrow`Sparse matrices	Exact	Returns the number of rows of a sparse matrix.
`sparsemat_numeric_destroy`Sparse matrices	Unit tests	Frees the result of `sparsemat_lu` or `sparsemat_qr`.
`sparsemat_numeric_t`Sparse matrices	Unit tests	The result of a numeric factorization (`sparsemat_lu` or `sparsemat_qr`).
`sparsemat_permute`Sparse matrices	Within tolerance	Reorders the rows and columns of a sparse matrix by two permutations.
`sparsemat_print`Sparse matrices	Unit tests	Writes the non-zero entries of a sparse matrix to a stream as text.
`sparsemat_qr`Sparse matrices	Within tolerance	Computes the Householder QR decomposition of a sparse matrix.
`sparsemat_qrresol`Sparse matrices	Within tolerance	Solves a linear system with a QR decomposition computed earlier: least squares or minimum norm.
`sparsemat_realloc`Sparse matrices	Unit tests	Changes the room a sparse matrix has for entries.
`sparsemat_resize`Sparse matrices	Unit tests	Replaces a sparse matrix by an empty one of a new shape.
`sparsemat_rowsums`Sparse matrices	Within tolerance	Computes the sum of each row of a sparse matrix.
`sparsemat_scale`Sparse matrices	Unit tests	Multiplies every stored value by a constant.
`sparsemat_solve_t`Sparse matrices	Unit tests	Which factorization `sparsemat_arpack_rssolve` uses for the shifted system in mode 3.
`sparsemat_sort`Sparse matrices	Exact	Creates a copy of a sparse matrix with its entries ordered by column, then by row.
`sparsemat_symblu`Sparse matrices	Within tolerance	Prepares an LU decomposition: chooses the column order of a square sparse matrix.
`sparsemat_symbolic_destroy`Sparse matrices	Unit tests	Frees the result of `sparsemat_symblu` or `sparsemat_symbqr`.
`sparsemat_symbolic_t`Sparse matrices	Unit tests	The result of a symbolic analysis (`sparsemat_symblu` or `sparsemat_symbqr`).
`sparsemat_symbqr`Sparse matrices	Within tolerance	Prepares a QR decomposition: column order, column elimination tree and row placement.
`sparsemat_t`Sparse matrices	Unit tests	A sparse real matrix, in triplet or column-compressed form.
`sparsemat_transpose`Sparse matrices	Within tolerance	Computes the transpose of a sparse matrix.
`sparsemat_type`Sparse matrices	Exact	Tells which of the two layouts a sparse matrix uses.
`sparsemat_type_t`Sparse matrices	Unit tests	The two layouts of a sparse matrix.
`sparsemat_usolve`Sparse matrices	Within tolerance	Solves U x = b for an upper triangular sparse matrix U.
`sparsemat_utsolve`Sparse matrices	Within tolerance	Solves U' x = b for an upper triangular sparse matrix U (using its transpose).
`spatial_edge_lengths`Spatial graphs and numbers	Unit tests	Computes the length of every edge from the coordinates of its end points.
`split_join_distance`Community detection	Exact	Gives the two projection distances between two partitions; their sum is the split-join distance.
`square_lattice`Deterministic generators	Exact	Builds a square grid lattice in any number of dimensions, optionally periodic.
`st_edge_connectivity`Flows, cuts and traversal	Exact	Smallest number of edges whose removal leaves no path from the source to the target.
`st_mincut`Flows, cuts and traversal	Exact	Minimum s-t cut: the cheapest edge set whose removal separates the target from the source.
`st_mincut_value`Flows, cuts and traversal	Exact	Capacity of a minimum cut between two vertices.
`st_vertex_connectivity`Flows, cuts and traversal	Exact	Smallest number of vertices whose removal leaves no path from the source to the target.
`stack_clear`Matrices, stacks, queues and heaps	Unit tests	Empties a stack but keeps its storage.
`stack_destroy`Matrices, stacks, queues and heaps	Unit tests	Frees the storage of a stack.
`stack_empty`Matrices, stacks, queues and heaps	Unit tests	Tells whether a stack has no elements.
`stack_init`Matrices, stacks, queues and heaps	Unit tests	Creates an empty stack with room for a given number of elements.
`stack_pop`Matrices, stacks, queues and heaps	Unit tests	Removes the top element of a stack and returns it.
`stack_push`Matrices, stacks, queues and heaps	Unit tests	Pushes an element; it becomes the new top of the stack.
`stack_reserve`Matrices, stacks, queues and heaps	Unit tests	Makes room for at least a given number of elements.
`stack_size`Matrices, stacks, queues and heaps	Unit tests	Tells how many elements a stack holds.
`stack_t`Matrices, stacks, queues and heaps	Unit tests	A last-in, first-out stack of real numbers.
`stack_top`Matrices, stacks, queues and heaps	Unit tests	Returns the top element of a stack without removing it.
`star`Deterministic generators	Exact	Builds a star: one center vertex joined to every other vertex.
`static_fitness_game`Random graphs	Same quality	Draws a graph with a fixed number of edges whose endpoints are chosen in proportion to vertex fitness.
`static_power_law_game`Random graphs	Same quality	Draws a graph with a power-law degree distribution through the static fitness model.
`status`Hierarchical random graphs and progress	Unit tests	Reports a status message to the calling thread's status handler.
`status_handler_stderr`Hierarchical random graphs and progress	Unit tests	A ready-made status handler that writes to stderr.
`status_handler_t`Hierarchical random graphs and progress	Unit tests	The type of a function that receives status messages.
`statusf`Hierarchical random graphs and progress	Unit tests	Reports a status message with a printf-style template.
`strength`Centrality	Exact	Weighted degree: the total weight of the edges at each chosen vertex.
`strerror`Graph basics	Unit tests	A short English text for an error code.
`strvector_append`String vectors, lists and bit sets	Unit tests	Appends copies of all strings of one vector to another.
`strvector_capacity`String vectors, lists and bit sets	Unit tests	Returns how many entries fit before the vector must reallocate.
`strvector_clear`String vectors, lists and bit sets	Unit tests	Removes every entry and keeps the allocated capacity.
`strvector_destroy`String vectors, lists and bit sets	Unit tests	Releases a string vector together with all its strings.
`strvector_get`String vectors, lists and bit sets	Unit tests	Returns the string at a position; an empty entry reads as "".
`strvector_init`String vectors, lists and bit sets	Unit tests	Creates a string vector holding `size` empty strings.
`strvector_init_copy`String vectors, lists and bit sets	Unit tests	Creates a string vector that is a deep copy of another.
`strvector_merge`String vectors, lists and bit sets	Unit tests	Hands all strings of one vector over to another, appending them without copying.
`strvector_push_back`String vectors, lists and bit sets	Unit tests	Appends a copy of a string at the end.
`strvector_push_back_len`String vectors, lists and bit sets	Unit tests	Appends at most `len` bytes of a string at the end.
`strvector_remove`String vectors, lists and bit sets	Unit tests	Removes one entry and moves the later entries down by one.
`strvector_remove_section`String vectors, lists and bit sets	Unit tests	Removes the entries at positions from .. to-1.
`strvector_reserve`String vectors, lists and bit sets	Unit tests	Allocates room for at least `capacity` entries.
`strvector_resize`String vectors, lists and bit sets	Unit tests	Grows or shrinks a string vector to a given number of entries.
`strvector_resize_min`String vectors, lists and bit sets	Unit tests	Shrinks the allocated storage to the current number of entries.
`strvector_set`String vectors, lists and bit sets	Unit tests	Replaces the string at a position with a copy of `value`.
`strvector_set_len`String vectors, lists and bit sets	Unit tests	Replaces the string at a position with at most `len` bytes of `value`.
`strvector_size`String vectors, lists and bit sets	Unit tests	Tells how many entries a string vector holds.
`strvector_swap`String vectors, lists and bit sets	Unit tests	Exchanges what two string vectors hold.
`strvector_swap_elements`String vectors, lists and bit sets	Unit tests	Exchanges two entries of a string vector.
`strvector_update`String vectors, lists and bit sets	Unit tests	Overwrites a string vector with a copy of another.
`subcomponent`Components and structure	Exact	Lists the vertices reachable from a vertex, in breadth-first order.
`subgraph_from_edges`Operators and bipartite graphs	Exact	Subgraph made of the selected edges.
`subgraph_implementation_t`Operators and bipartite graphs	Unit tests	How `induced_subgraph` builds its result.
`subisomorphic`Isomorphism	Exact	Decides whether graph2 occurs as a subgraph of graph1.
`subisomorphic_lad`Isomorphism	Exact	Finds copies of a pattern graph in a target graph with Solnon's LAD algorithm, optionally induced and with candidate lists per vertex.
`subisomorphic_vf2`Isomorphism	Exact	Decides with VF2 whether graph2 occurs as a subgraph of graph1, and returns the first match.
`symmetric_tree`Deterministic generators	Unit tests	Builds a tree whose number of children is set level by level.
`task_fn_t`Threads	Unit tests Threads Extension	One task of a parallel kernel: runs part task of the kernel's work.
`to_directed`Components and structure	Exact	Turns an undirected graph into a directed one, in place.
`to_prufer`Components and structure	Exact	Encodes a labelled tree as its Pruefer sequence.
`to_undirected`Components and structure	Exact	Turns a directed graph into an undirected one, in place.
`topological_sorting`Cycles, motifs and epidemics	Exact	Orders the vertices of a DAG so that every edge points the same way along the order.
`transitive_closure`Components and structure	Unit tests SIMD	Builds the graph with an edge from every vertex to every vertex it can reach.
`transitivity_avglocal_undirected`Similarity, transitivity and mixing	Exact	Computes the average of the local clustering coefficients.
`transitivity_barrat`Similarity, transitivity and mixing	Exact	Computes the weighted local clustering coefficient of Barrat et al.
`transitivity_local_undirected`Similarity, transitivity and mixing	Exact	Computes the local clustering coefficient of selected vertices.
`transitivity_undirected`Similarity, transitivity and mixing	Exact	Computes the global clustering coefficient: the share of connected triples that are closed.
`tree_from_parent_vector`Deterministic generators	Exact	Turns a vector of parent ids into a tree or forest.
`tree_game`Random graphs	Same quality	Draws a uniformly random labelled tree on n vertices.
`triad_census`Cycles, motifs and epidemics	Exact Threads	Counts the triads of a directed graph in each of the 16 isomorphism classes.
`triangular_lattice`Deterministic generators	Exact	Builds a lattice of triangles in one of three outlines.
`trussness`Components and structure	Exact	Computes the trussness of every edge.
`turan`Deterministic generators	Exact	Builds the Turán graph T(n, r): the complete r-partite graph with parts as equal as possible.
`unfold_tree`Paths and distances	Exact	Unfolds a graph into a forest by a breadth-first walk from given roots, copying vertices that are reached more than once.
`union`Operators and bipartite graphs	Exact	Union of two graphs on shared vertex ids.
`union_many`Operators and bipartite graphs	Exact	Union of any number of graphs on shared vertex ids.
`vconn_nei_t`Flows, cuts and traversal	Unit tests	What `st_vertex_connectivity` does when source and target are adjacent.
`vcount`Graph basics	Exact	How many vertices the graph has.
`vector_add`Vectors	Unit tests	Adds a second vector element by element: v1[i] += v2[i].
`vector_add_constant`Vectors	Unit tests	Adds the same value to every element.
`vector_all_almost_e`Vectors	Unit tests	Tells whether two real vectors agree element by element within a relative tolerance.
`vector_all_e`Vectors	Unit tests	Tells whether two vectors have the same size and equal elements.
`vector_all_g`Vectors	Unit tests	Tells whether lhs[i] > rhs[i] at every position.
`vector_all_ge`Vectors	Unit tests	Tells whether lhs[i] >= rhs[i] at every position.
`vector_all_l`Vectors	Unit tests	Tells whether lhs[i] < rhs[i] at every position.
`vector_all_le`Vectors	Unit tests	Tells whether lhs[i] <= rhs[i] at every position.
`vector_append`Vectors	Unit tests	Appends the elements of one vector to the end of another.
`vector_binsearch`Vectors	Unit tests	Binary search in a sorted vector.
`vector_binsearch_slice`Vectors	Unit tests	Binary search within positions start .. end - 1 of a sorted vector.
`vector_capacity`Vectors	Unit tests	The number of elements the allocated storage can hold.
`vector_clear`Vectors	Unit tests	Removes all elements and keeps the storage.
`vector_colex_cmp`Vectors	Unit tests	Compares two vectors colexicographically: from the last element backwards.
`vector_colex_cmp_untyped`Vectors	Unit tests	`vector_colex_cmp` in the form a qsort-style sort expects.
`vector_complex_all_almost_e`Vectors	Unit tests	Tells whether two complex vectors agree element by element within a relative tolerance.
`vector_complex_create`Vectors	Unit tests	Makes a new complex vector by pairing two real vectors as components.
`vector_complex_create_polar`Vectors	Unit tests	Builds a complex vector from magnitudes and angles.
`vector_complex_imag`Vectors	Unit tests	Copies out the imaginary component of each complex entry.
`vector_complex_real`Vectors	Unit tests	Copies out the real component of each complex entry.
`vector_complex_realimag`Vectors	Unit tests	Copies out both components of each complex entry in a single call.
`vector_complex_zapsmall`Vectors	Unit tests	Zeroes tiny real and imaginary parts, each part on its own.
`vector_contains`Vectors	Unit tests	Tells whether a value occurs in a vector.
`vector_contains_sorted`Vectors	Unit tests	Tells whether a value occurs in a sorted vector, by binary search.
`vector_copy_to`Vectors	Unit tests	Copies all elements into a C array.
`vector_destroy`Vectors	Unit tests	Frees a vector's storage.
`vector_difference_and_intersection_sorted`Vectors	Unit tests	The v1-only, v2-only and shared elements of two ascending vectors, from one merge pass.
`vector_difference_sorted`Vectors	Unit tests	What remains of ascending v1 after taking away the elements of ascending v2, multiplicities subtracted.
`vector_div`Vectors	Unit tests	Divides by a second vector element by element: v1[i] /= v2[i].
`vector_empty`Vectors	Unit tests	Tells whether a vector has no elements.
`vector_fill`Vectors	Unit tests	Sets every element to the same value.
`vector_floor`Vectors	Unit tests	Rounds every element of a real vector down into an integer vector.
`vector_get`Vectors	Unit tests	Reads one element.
`vector_get_ptr`Vectors	Unit tests	The address of one element.
`vector_index`Vectors	Unit tests	Builds a vector from chosen elements of another: newv[i] = v[idx[i]].
`vector_index_in_place`Vectors	Unit tests	Replaces a vector by chosen elements of itself: v[i] becomes the old v[idx[i]].
`vector_init`Vectors	Unit tests	Creates a vector of a given length with every element zero.
`vector_init_array`Vectors	Unit tests	Creates a vector holding a copy of the values of a C array.
`vector_init_copy`Vectors	Unit tests	Creates a vector with the same elements as another.
`vector_init_range`Vectors	Unit tests	Creates a vector holding start, start + 1, ..., up to but not including end.
`vector_insert`Vectors	Unit tests	Inserts a value at a position, moving the later elements one place to the right.
`vector_intersect_sorted`Vectors	Unit tests	Common elements of two ascending vectors, counted with multiplicity.
`vector_intersection_size_sorted`Vectors	Unit tests	The size of the multiset intersection of two sorted vectors, without building it.
`vector_is_all_finite`Vectors	Unit tests	Tells whether every element is finite (neither infinite nor NaN).
`vector_is_any_nan`Vectors	Unit tests	True if at least one entry is not a number.
`vector_is_equal`Vectors	Unit tests	Tells whether two vectors are equal; the same test as `vector_all_e`.
`vector_is_nan`Vectors	Unit tests	Marks which elements are NaN.
`vector_isininterval`Vectors	Unit tests	Tells whether every element lies between low and high, both included.
`vector_lex_cmp`Vectors	Unit tests	Compares two vectors lexicographically.
`vector_lex_cmp_untyped`Vectors	Unit tests	`vector_lex_cmp` in the form a qsort-style sort expects.
`vector_list_capacity`String vectors, lists and bit sets	Unit tests	Returns how many items fit before the list must reallocate.
`vector_list_clear`String vectors, lists and bit sets	Unit tests	Destroys all items and keeps the allocated capacity.
`vector_list_destroy`String vectors, lists and bit sets	Unit tests	Destroys every item of a list and frees the list.
`vector_list_discard`String vectors, lists and bit sets	Unit tests	Destroys the item at a position and closes the gap.
`vector_list_discard_back`String vectors, lists and bit sets	Unit tests	Destroys the last item of a list, if there is one.
`vector_list_discard_fast`String vectors, lists and bit sets	Unit tests	Destroys the item at a position; the last item fills its place.
`vector_list_empty`String vectors, lists and bit sets	Unit tests	Tells whether a list has no items.
`vector_list_get_ptr`String vectors, lists and bit sets	Unit tests	Returns a pointer to the item at a position.
`vector_list_init`String vectors, lists and bit sets	Unit tests	Creates a list of `size` new, empty items.
`vector_list_init_copy`String vectors, lists and bit sets	Unit tests	Creates a list holding deep copies of another list's items.
`vector_list_insert`String vectors, lists and bit sets	Unit tests	Inserts the caller's item at a position, taking ownership of it.
`vector_list_insert_copy`String vectors, lists and bit sets	Unit tests	Inserts a deep copy of an item at a position.
`vector_list_insert_new`String vectors, lists and bit sets	Unit tests	Inserts a new, empty item at a position and can return a pointer to it.
`vector_list_permute`String vectors, lists and bit sets	Unit tests	Reorders a list: new position i receives the item at old position index[i].
`vector_list_pop_back`String vectors, lists and bit sets	Unit tests	Takes the last item off a list and returns it; the caller then owns it.
`vector_list_push_back`String vectors, lists and bit sets	Unit tests	Appends the caller's item to the list, taking ownership of it.
`vector_list_push_back_copy`String vectors, lists and bit sets	Unit tests	Appends a deep copy of an item.
`vector_list_push_back_new`String vectors, lists and bit sets	Unit tests	Appends a new, empty item and can return a pointer to it.
`vector_list_remove`String vectors, lists and bit sets	Unit tests	Takes the item at a position out of the list and hands it to the caller.
`vector_list_remove_fast`String vectors, lists and bit sets	Unit tests	Takes an item out of the list in constant time; the last item fills its place.
`vector_list_replace`String vectors, lists and bit sets	Unit tests	Exchanges the item at a position with the caller's item.
`vector_list_reserve`String vectors, lists and bit sets	Unit tests	Allocates room for at least `capacity` items without changing the list.
`vector_list_resize`String vectors, lists and bit sets	Unit tests	Changes the number of items of a list.
`vector_list_set`String vectors, lists and bit sets	Unit tests	Puts the caller's item at a position and destroys the item that was there.
`vector_list_size`String vectors, lists and bit sets	Unit tests	Returns the number of items in a list.
`vector_list_sort`String vectors, lists and bit sets	Unit tests	Sorts the items of a list in place with a comparison function.
`vector_list_sort_ind`String vectors, lists and bit sets	Unit tests	Writes the positions of a list's items in sorted order, without moving them.
`vector_list_swap`String vectors, lists and bit sets	Unit tests	Exchanges the contents of two lists of the same type.
`vector_list_swap_elements`String vectors, lists and bit sets	Unit tests	Exchanges two items of a list.
`vector_list_t`Vectors	Unit tests	A growable list of real vectors that owns its items.
`vector_list_tail_ptr`String vectors, lists and bit sets	Unit tests	Returns a pointer to the last item, or NULL for an empty list.
`vector_max`Vectors	Unit tests	The largest element.
`vector_maxdifference`Vectors	Unit tests	The largest absolute difference between corresponding elements of two vectors.
`vector_min`Vectors	Unit tests	The smallest element.
`vector_minmax`Vectors	Unit tests	The smallest and the largest element in one pass.
`vector_mul`Vectors	Unit tests	Multiplies by a second vector element by element: v1[i] *= v2[i].
`vector_null`Vectors	Unit tests	Overwrites all elements with the zero value of the element type.
`vector_permute`Vectors	Unit tests	Reorders a vector by an index vector: position i receives the old element index[i].
`vector_pop_back`Vectors	Unit tests	Takes the final entry off the vector and hands it back.
`vector_prod`Vectors	Unit tests	Multiplies all entries together.
`vector_ptr_capacity`Vectors	Unit tests	The number of pointers the allocated storage can hold.
`vector_ptr_clear`Vectors	Unit tests	Removes all elements, running the item destructor on each one that is not NULL.
`vector_ptr_destroy`Vectors	Unit tests	Frees a pointer vector, running the item destructor on its elements.
`vector_ptr_destroy_all`Vectors	Unit tests	Frees every element and then the vector itself.
`vector_ptr_free_all`Vectors	Unit tests	Destroys and frees every element, leaving NULL in each slot.
`vector_ptr_get`Vectors	Unit tests	Reads one pointer.
`vector_ptr_get_item_destructor`Vectors	Unit tests	Reports which function, if any, runs on elements when they are destroyed.
`vector_ptr_init`Vectors	Unit tests	Creates a pointer vector of `size` NULL pointers.
`vector_ptr_init_copy`Vectors	Unit tests	Creates a shallow copy of a pointer vector.
`vector_ptr_insert`Vectors	Unit tests	Inserts a pointer at a position, moving the later ones one place to the right.
`vector_ptr_permute`Vectors	Unit tests	Reorders a pointer vector by an index vector: position i receives the old element index[i].
`vector_ptr_pop_back`Vectors	Unit tests	Takes the final pointer off the vector and hands it back.
`vector_ptr_push_back`Vectors	Unit tests	Appends one pointer.
`vector_ptr_reserve`Vectors	Unit tests	Makes room for at least `capacity` pointers without changing the size.
`vector_ptr_resize`Vectors	Unit tests	Changes the number of elements of a pointer vector.
`vector_ptr_resize_min`Vectors	Unit tests	Releases unused storage: the capacity becomes equal to the size.
`vector_ptr_set`Vectors	Unit tests	Stores a pointer at a position.
`vector_ptr_set_item_destructor`Vectors	Unit tests	Sets the function that destroy, clear and free_all run on each element.
`vector_ptr_size`Vectors	Unit tests	Count of slots in a pointer vector.
`vector_ptr_sort`Vectors	Unit tests	Sorts the pointers with a comparison function.
`vector_ptr_sort_ind`Vectors	Unit tests	The permutation that sorts a pointer vector by a comparison function.
`vector_push_back`Vectors	Unit tests	Grows the vector by one, storing a value at the new end.
`vector_range`Vectors	Unit tests	Fills a vector with start, start + 1, ..., up to but not including end.
`vector_remove`Vectors	Unit tests	Removes the element at a position, moving the later elements one place to the left.
`vector_remove_section`Vectors	Unit tests	Removes the elements at positions from .. to - 1.
`vector_reserve`Vectors	Unit tests	Makes room for at least `capacity` elements without changing the size.
`vector_resize`Vectors	Unit tests	Changes the number of elements.
`vector_resize_min`Vectors	Unit tests	Releases unused storage: the capacity becomes equal to the size.
`vector_reverse`Vectors	Unit tests	Reverses the order of the elements.
`vector_reverse_section`Vectors	Unit tests	Reverses the elements at positions from .. to - 1.
`vector_reverse_sort`Vectors	Unit tests	Puts the entries in decreasing order, in place.
`vector_rotate_left`Vectors	Unit tests	Cyclic shift: moves every element n positions towards the front, wrapping around.
`vector_scale`Vectors	Unit tests	Multiplies every element by the same value.
`vector_search`Vectors	Unit tests	Finds the first position at or after `from` that holds a value.
`vector_set`Vectors	Unit tests	Writes one element.
`vector_shuffle`Vectors	Same quality	Puts the elements in a uniformly random order.
`vector_size`Vectors	Unit tests	The number of elements.
`vector_sort`Vectors	Unit tests	Puts the entries in increasing order, in place (introsort).
`vector_sort_ind`Vectors	Unit tests	The permutation that sorts a vector, leaving the vector itself unchanged.
`vector_sub`Vectors	Unit tests	Subtracts a second vector element by element: v1[i] -= v2[i].
`vector_sum`Vectors	Unit tests	Adds up all entries.
`vector_swap`Vectors	Unit tests	Exchanges the contents of two vectors.
`vector_swap_elements`Vectors	Unit tests	Exchanges two elements.
`vector_t`Vectors	Unit tests	A growable array of reals; the template for the integer, bool, char, complex and pointer vectors.
`vector_tail`Vectors	Unit tests	Reads the final entry without removing it.
`vector_update`Vectors	Unit tests	Makes one vector an element-by-element copy of another.
`vector_view`Vectors	Unit tests	Wraps an existing C array as a vector, without copying.
`vector_which_max`Vectors	Unit tests	Index where the maximum sits (the first one on ties).
`vector_which_min`Vectors	Unit tests	Index where the minimum sits (the first one on ties).
`vector_which_minmax`Vectors	Unit tests	The positions of the smallest and the largest element in one pass.
`vector_zapsmall`Vectors	Unit tests	Snaps near-zero entries to exactly 0 using an absolute threshold.
`version`Spatial graphs and numbers	Unit tests	Reports the version of the Open Graph library.
`vertex_coloring_greedy`Cliques, independent sets and colouring	Same quality	Colours the vertices greedily so that adjacent vertices get different colours.
`vertex_connectivity`Flows, cuts and traversal	Exact	Smallest number of vertices whose removal disconnects the graph.
`vertex_disjoint_paths`Flows, cuts and traversal	Exact	Largest number of source-target paths that share no vertex apart from their ends.
`vertex_path_from_edge_path`Paths and distances	Exact	Converts a walk given as edge ids into the sequence of vertices it visits.
`vit_create`Graph basics	Unit tests	Resolves a vertex selector against a graph into an iterator.
`vit_destroy`Graph basics	Unit tests	Releases any id list a vertex iterator built.
`voronoi`Paths and distances	Exact	Assigns each vertex to its nearest generator vertex (a graph Voronoi partition).
`vs_1`Graph basics	Unit tests	Selector naming exactly one vertex id.
`vs_adj`Graph basics	Unit tests	Vertex selector for the neighbours of one vertex.
`vs_all`Graph basics	Unit tests	Vertex selector for every vertex of the graph.
`vs_copy`Graph basics	Unit tests	Copies a vertex selector.
`vs_destroy`Graph basics	Unit tests	Frees what a vertex selector owns.
`vs_is_all`Graph basics	Unit tests	Tells whether a selector is the all-vertices selector.
`vs_nonadj`Graph basics	Unit tests	Vertex selector for the vertices not adjacent to one vertex.
`vs_none`Graph basics	Unit tests	Selector that resolves to no vertex at all.
`vs_range`Graph basics	Unit tests	Vertex selector for the ids start, start + 1, ..., end - 1.
`vs_size`Graph basics	Unit tests	The number of vertices a selector resolves to in a graph.
`vs_type`Graph basics	Unit tests	Reports which variant (all, range, vector, ...) a vertex selector is.
`vs_vector`Graph basics	Unit tests	Vertex selector that borrows the caller's vector of vertex ids.
`vs_vector_copy`Graph basics	Unit tests	Vertex selector that keeps its own copy of a vector of vertex ids.
`vs_vector_small`Graph basics	Unit tests	Vertex selector from int arguments ending in -1.
`vss_1`Graph basics	Unit tests	Immediate selector for a single vertex.
`vss_all`Graph basics	Unit tests	Immediate selector for every vertex.
`vss_none`Graph basics	Unit tests	Immediate selector for no vertices.
`vss_range`Graph basics	Unit tests	Immediate selector for the ids start .. end - 1.
`vss_vector`Graph basics	Unit tests	Immediate selector that borrows a vector of vertex ids.
`warning`Graph basics	Unit tests	Passes a warning message to the installed warning handler.
`warning_handler_ignore`Graph basics	Unit tests	Warning handler that does nothing.
`warning_handler_print`Graph basics	Unit tests	The default warning handler: prints the warning to stderr.
`warning_handler_t`Graph basics	Unit tests	Function type for the routine that receives warnings.
`warningf`Graph basics	Unit tests	Raises a warning with a printf-style message.
`watts_strogatz_game`Random graphs	Same quality	Draws a small-world graph: a periodic lattice whose edges are rewired at random (Watts-Strogatz).
`weighted_adjacency`Deterministic generators	Exact	Builds a weighted graph from a square matrix, one edge per non-zero entry.
`weighted_biadjacency`Operators and bipartite graphs	Exact	Builds a weighted bipartite graph from a biadjacency matrix.
`weighted_clique_number`Cliques, independent sets and colouring	Unit tests	Largest total vertex weight of a clique.
`weighted_cliques`Cliques, independent sets and colouring	Unit tests	Lists cliques, or maximal cliques, whose total vertex weight lies in a range.
`wheel`Deterministic generators	Exact	Builds a wheel: a star whose outer vertices also form a cycle.
`widest_path_widths_dijkstra`Paths and distances	Exact	Widest-path widths from a set of sources to a set of targets.
`widest_path_widths_floyd_warshall`Paths and distances	Exact	Widest-path widths between all pairs, by the bottleneck form of Floyd-Warshall.
`write_graph_dimacs_flow`Reading and writing files	Exact	Writes a maximum-flow problem in the DIMACS format.
`write_graph_dot`Reading and writing files	Exact	Writes the graph and its attributes in the Graphviz DOT language.
`write_graph_edgelist`Reading and writing files	Exact	Writes every edge as one line holding the two vertex ids.
`write_graph_gml`Reading and writing files	Exact	Writes the graph and its attributes in the GML format.
`write_graph_graphml`Reading and writing files	Exact	Writes the graph and all its graph, vertex and edge attributes as a GraphML document.
`write_graph_leda`Reading and writing files	Exact	Writes the graph in LEDA's native graph format, with at most one vertex and one edge attribute as data.
`write_graph_lgl`Reading and writing files	Exact	Writes the graph in the LGL format, one "# vertex" block per vertex that has edges starting at it.
`write_graph_ncol`Reading and writing files	Exact	Writes the edges as "name name [weight]" lines in the NCOL format.
`write_graph_pajek`Reading and writing files	Exact	Writes the graph as a Pajek .net file, with names, coordinates, weights and the drawing parameters Pajek knows.

Last updated 6 November 2026 · Open Graph 0.1.0 · OpenBI Studio 0.3.78