search in docstrings

Search bar offers the following options:

- Term presence. The below example searches for documents that must contain “foo”, might contain “bar” and must not contain “baz”: `+foo bar -baz`
- Wildcards. The below example searches for documents with words beginning with “foo”: `foo*`
- Search in specific fields. The following search matches all objects in "twisted.mail" that matches “search”: `+qname:twisted.mail.* +search`

  Possible fields: 'name', 'qname' (fully qualified name), 'docstring', and 'kind'. Last two fields are only applicable if "search in docstrings" is enabled.

- Fuzzy matches. The following search matches all documents that have a word within 1 edit distance of “foo”: `foo~1`

Results provided by Lunr.js

# ``igraph`.`io`.`bipartite``

module documentation
(source)

Undocumented

Function | `_construct_bipartite_graph` | Creates a bipartite graph with the given vertex types and edges. This is similar to the default constructor of the graph, the only difference is that it checks whether all the edges go between the two vertex classes and it assigns the type vector to a ...
Function | `_construct_bipartite_graph_from_adjacency` | Creates a bipartite graph from a bipartite adjacency matrix.
Function | `_construct_full_bipartite_graph` | Generates a full bipartite graph (directed or undirected, with or without loops).
Function | `_construct_random_bipartite_graph` | Generates a random bipartite graph with the given number of vertices and edges (if m is given), or with the given number of vertices and the given connection probability (if p is given).

def _construct_bipartite_graph(cls, types, edges, directed=False, *args, **kwds): (source)

Creates a bipartite graph with the given vertex types and edges. This is similar to the default constructor of the graph, the only difference is that it checks whether all the edges go between the two vertex classes and it assigns the type vector to a `type` attribute afterwards.

Examples:

    >>> g = Graph.Bipartite([0, 1, 0, 1], [(0, 1), (2, 3), (0, 3)])
    >>> g.is_bipartite()
    True
    >>> g.vs["type"]
    [False, True, False, True]

Parameters
cls | Undocumented
types | the vertex types as a boolean list. Anything that evaluates to `False` will denote a vertex of the first kind, anything that evaluates to `True` will denote a vertex of the second kind.
edges | the edges as a list of tuples.
directed | whether to create a directed graph. Bipartite networks are usually undirected, so the default is `False`
*args | Undocumented
**kwds | Undocumented
Returns
the graph with a binary vertex attribute named `"type"` that stores the vertex classes.

def _construct_bipartite_graph_from_adjacency(cls, matrix, directed=False, mode='out', multiple=False, weighted=None, *args, **kwds): (source)

Creates a bipartite graph from a bipartite adjacency matrix.

Example:

    >>> g = Graph.Biadjacency([[0, 1, 1], [1, 1, 0]])

Parameters
cls | Undocumented
matrix | the bipartite adjacency matrix.
directed | whether to create a directed graph.
mode | defines the direction of edges in the graph. If `"out"`, then edges go from vertices of the first kind (corresponding to rows of the matrix) to vertices of the second kind (the columns of the matrix). If `"in"`, the opposite direction is used. `"all"` creates mutual edges. Ignored for undirected graphs.
multiple | defines what to do with non-zero entries in the matrix. If `False`, non-zero entries will create an edge no matter what the value is. If `True`, non-zero entries are rounded up to the nearest integer and this will be the number of multiple edges created.

weighted

defines whether to create a weighted graph from the adjacency matrix. If it is c{None} then an unweighted graph is created and the multiple argument is used to determine the edges of the graph. If it is a string then for every non-zero matrix entry, an edge is created and the value of the entry is added as an edge attribute named by the weighted argument. If it is `True` then a weighted graph is created and the name of the edge attribute will be `"weight"`.

*args | Undocumented
**kwds | Undocumented
Returns
the graph with a binary vertex attribute named `"type"` that stores the vertex classes.
Raises
`ValueError` | if the weighted and multiple are passed together.

def _construct_full_bipartite_graph(cls, n1, n2, directed=False, mode='all', *args, **kwds): (source)

Generates a full bipartite graph (directed or undirected, with or without loops).

    >>> g = Graph.Full_Bipartite(2, 3)
    >>> g.is_bipartite()
    True
    >>> g.vs["type"]
    [False, False, True, True, True]

Parameters
cls | Undocumented
n1 | the number of vertices of the first kind.
n2 | the number of vertices of the second kind.
directed | whether tp generate a directed graph.
mode | if `"out"`, then all vertices of the first kind are connected to the others; `"in"` specifies the opposite direction, `"all"` creates mutual edges. Ignored for undirected graphs.
*args | Undocumented
**kwds | Undocumented
Returns
the graph with a binary vertex attribute named `"type"` that stores the vertex classes.

def _construct_random_bipartite_graph(cls, n1, n2, p=None, m=None, directed=False, neimode='all', *args, **kwds): (source)

Generates a random bipartite graph with the given number of vertices and edges (if m is given), or with the given number of vertices and the given connection probability (if p is given).

If m is given but p is not, the generated graph will have n1 vertices of type 1, n2 vertices of type 2 and m randomly selected edges between them. If p is given but m is not, the generated graph will have n1 vertices of type 1 and n2 vertices of type 2, and each edge will exist between them with probability p.

Parameters
cls | Undocumented
n1 | the number of vertices of type 1.
n2 | the number of vertices of type 2.
p | the probability of edges. If given, `m` must be missing.
m | the number of edges. If given, `p` must be missing.
directed | whether to generate a directed graph.
neimode | if the graph is directed, specifies how the edges will be generated. If it is `"all"`, edges will be generated in both directions (from type 1 to type 2 and vice versa) independently. If it is `"out"` edges will always point from type 1 to type 2. If it is `"in"`, edges will always point from type 2 to type 1. This argument is ignored for undirected graphs.
*args | Undocumented
**kwds | Undocumented