Silmathoron / NNGT / 823

pending completion

Build # 823

Build Type

Pull #65

travis-ci-com

Committed by

web-flow

Commit Message

<a href="https://github.com/Silmathoron/NNGT/commit/<a class=hub.com/Silmathoron/NNGT/commit/<a class="double-link" href="https://git"><a class=hub.com/Silmathoron/NNGT/commit/<a class="double-link" href="https://git"><a class=hub.com/Silmathoron/NNGT/commit/<a class="double-link" href="https://git"><a class=hub.com/Silmathoron/NNGT/commit/<a class="double-link" href="https://git"><a class=hub.com/Silmathoron/NNGT/commit/626a3bd3be2ce155035cabb8863dd0a75a30152d">626a3bd3b">&lt;a href=&quot;https://github.com/Silmathoron/NNGT/commit/</a><a class="double-link" href="https://github.com/Silmathoron/NNGT/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Silmathoron/NNGT/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Silmathoron/NNGT/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Silmathoron/NNGT/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Silmathoron/NNGT/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Silmathoron/NNGT/commit/626a3bd3be2ce155035cabb8863dd0a75a30152d">626a3bd3b</a><a href="https://github.com/Silmathoron/NNGT/commit/626a3bd3be2ce155035cabb8863dd0a75a30152d">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/Silmathoron/NNGT/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/Silmathoron/NNGT/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Silmathoron/NNGT/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Silmathoron/NNGT/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Silmathoron/NNGT/commit/626a3bd3be2ce155035cabb8863dd0a75a30152d&quot;&gt;626a3bd3b&lt;/a&gt;&lt;a href=&quot;https://github.com/Silmathoron/NNGT/commit/626a3bd3be2ce155035cabb8863dd0a75a30152d&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/Silmathoron/NNGT/commit/626a3bd3be2ce155035cabb8863dd0a75a30152d&amp;quot;&amp;gt;&amp;amp;quot;&amp;amp;gt;&amp;amp;amp;lt;a href=&amp;amp;amp;quot;https://github.com/Silmathoron/NNGT/commit/&amp;amp;lt;/a&amp;amp;gt;&amp;amp;lt;a class=&... (continued)

Pull Request Pull Request #65: Provide format choice for adjacency matrix

Run Details

1524 of 3177 branches covered (47.97%)

31 of 31 new or added lines in 5 files covered. (100.0%)

4260 of 7105 relevant lines covered (59.96%)

1.78 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.68

/nngt/analysis/ig_functions.py

#-*- coding:utf-8 -*-
#
# ig_functions.py
#
# This file is part of the NNGT project to generate and analyze
# neuronal networks and their activity.
# Copyright (C) 2015-2019  Tanguy Fardet
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

""" Tools to analyze graphs with the igraph backend """

import numpy as np
import scipy.sparse as ssp

from ..lib.test_functions import nonstring_container
from ..lib.graph_helpers import _get_ig_weights


def global_clustering(g, weights=None):
    '''
    Returns the undirected global clustering coefficient.
    This corresponds to the ratio of undirected triangles to the number of
    undirected triads.

    Parameters
    ----------
    g : :class:`~nngt.Graph`
        Graph to analyze.
    weights : bool or str, optional (default: binary edges)
        Whether edge weights should be considered; if ``None`` or ``False``
        then use binary edges; if ``True``, uses the 'weight' edge attribute,
        otherwise uses any valid edge attribute required.

    References
    ----------
    .. [ig-global-clustering] :igdoc:`transitivity_undirected`
    '''
    ww = _get_ig_weights(g, weights)

    if ww is not None:
        # raise warning
        return np.average(
            g.graph.as_undirected().transitivity_local_undirected(weights=ww))

    return np.array(g.graph.as_undirected().transitivity_undirected())


def undirected_local_clustering(g, weights=None, nodes=None,
                                combine_weights="sum"):
    '''
    Returns the local clustering coefficient of some `nodes`.

    Parameters
    ----------
    g : :class:`~nngt.Graph`
        Graph to analyze.
    weights : bool or str, optional (default: binary edges)
        Whether edge weights should be considered; if ``None`` or ``False``
        then use binary edges; if ``True``, uses the 'weight' edge attribute,
        otherwise uses any valid edge attribute required.
    nodes : list, optional (default: all nodes)
        The list of nodes for which the clutering will be returned
    combine_weights : str, optional (default: "sum")
        How the weights of directed edges between two nodes should be combined,
        among:

        * "sum": the sum of the edge attribute values will be used for the new
          edge.
        * "product": the product of the edge attribute values will be used for
          the new edge.
        * "mean": the mean of the edge attribute values will be used for the
          new edge.
        * "median": the median of the edge attribute values will be used for
          the new edge.
        * "min": the minimum of the edge attribute values will be used for the
          new edge.
        * "max": the maximum of the edge attribute values will be used for the
          new edge. 

    Returns
    -------
    lc : :class:`numpy.ndarray`
        The list of clustering coefficients, on per node.

    References
    ----------
    .. [ig-local-clustering] :igdoc:`transitivity_local_undirected`
    '''
    if weights is not None and not isinstance(weights, str):
        raise ValueError("Only existing attributes can be used as weights.")

    u = g.graph.as_undirected(combine_edges=combine_weights)
    u.simplify()

    return np.array(u.transitivity_local_undirected(nodes, weights=weights))


def assortativity(g, degree, weights=None):
    '''
    Returns the assortativity of the graph.
    This tells whether nodes are preferentially connected together depending
    on their degree.

    Parameters
    ----------
    g : :class:`~nngt.Graph`
        Graph to analyze.
    degree : str
        The type of degree that should be considered.
    weights : bool or str, optional (default: binary edges)
        Whether edge weights should be considered; if ``None`` or ``False``
        then use binary edges; if ``True``, uses the 'weight' edge attribute,
        otherwise uses any valid edge attribute required.

    References
    ----------
    .. [ig-assortativity] :igdoc:`assortativity`
    '''
    ww = _get_ig_weights(g, weights)

    node_attr = g.get_degrees(degree, weights=ww)

    return g.graph.assortativity(node_attr, directed=g.is_directed())


def reciprocity(g):
    '''
    Calculate the edge reciprocity of the graph.

    The reciprocity is defined as the number of edges that have a reciprocal
    edge (an edge between the same nodes but in the opposite direction)
    divided by the total number of edges.
    This is also the probability for any given edge, that its reciprocal edge
    exists.
    By definition, the reciprocity of undirected graphs is 1.

    Parameters
    ----------
    g : :class:`~nngt.Graph`
        Graph to analyze.

    References
    ----------
    .. [ig-reciprocity] :igdoc:`reciprocity`
    '''
    return g.graph.reciprocity(ignore_loops=True, mode="default")


def closeness(g, weights=None, nodes=None, mode="out", harmonic=False,
              default=np.NaN):
    r'''
    Returns the closeness centrality of some `nodes`.

    Closeness centrality of a node `u` is defined, for the harmonic version,
    as the sum of the reciprocal of the shortest path distance :math:`d_{uv}`
    from `u` to the N - 1 other nodes in the graph (if `mode` is "out",
    reciprocally :math:`d_{vu}`, the distance to `u` from another node v,
    if `mode` is "in"):

    .. math::

        C(u) = \frac{1}{N - 1} \sum_{v \neq u} \frac{1}{d_{uv}},

    or, using the arithmetic definition, as the reciprocal of the
    average shortest path distance to/from `u` over to all other nodes:

    .. math::

        C(u) = \frac{n - 1}{\sum_{v \neq u} d_{uv}},

    where `d_{uv}` is the shortest-path distance from `u` to `v`,
    and `n` is the number of nodes in the strongly-connected component (SCC).

    By definition, the distance is infinite when nodes are not connected by
    a path in the harmonic case (such that :math:`\frac{1}{d(v, u)} = 0`),
    while the distance itself is taken as zero for unconnected nodes in the
    first equation.

    Parameters
    ----------
    g : :class:`~nngt.Graph`
        Graph to analyze.
    weights : bool or str, optional (default: binary edges)
        Whether edge weights should be considered; if ``None`` or ``False``
        then use binary edges; if ``True``, uses the 'weight' edge attribute,
        otherwise uses any valid edge attribute required.
    nodes : list, optional (default: all nodes)
        The list of nodes for which the clutering will be returned
    mode : str, optional (default: "out")
        For directed graphs, whether the distances are computed from ("out") or
        to ("in") each of the nodes.
    harmonic : bool, optional (default: False)
        Whether the arithmetic (default) or the harmonic (recommended) version
        of the closeness should be used.

    Returns
    -------
    c : :class:`numpy.ndarray`
        The list of closeness centralities, on per node.

    .. warning ::
        For compatibility reasons (harmonic closeness is not implemented for
        igraph), the arithmetic version is used by default; however, it is
        recommended to use the harmonic version instead whenever possible.

    Note
    ----
    When requesting a subset of nodes, check whether it is faster to use
    `nodes`, or to compute all closeness centralities, then take the subset.

    References
    ----------
    .. [ig-closeness] :igdoc:`closeness`
    '''
    if harmonic:
        raise NotImplementedError("`harmonic` closeness is not available with "
                                  "igraph backend.")

    if not np.all(g.get_degrees("in")) or not np.all(g.get_degrees("out")):
        raise RuntimeError("igraph backend does not support closeness for "
                           "graphs containing nodes with zero in/out-degree.")

    ww = _get_ig_weights(g, weights)

    return g.graph.closeness(nodes, mode=mode, weights=ww)


def betweenness(g, btype="both", weights=None):
    '''
    Returns the normalized betweenness centrality of the nodes and edges.

    Parameters
    ----------
    g : :class:`~nngt.Graph`
        Graph to analyze.
    ctype : str, optional (default 'both')
        The centrality that should be returned (either 'node', 'edge', or
        'both'). By default, both betweenness centralities are computed.
    weights : bool or str, optional (default: binary edges)
        Whether edge weights should be considered; if ``None`` or ``False``
        then use binary edges; if ``True``, uses the 'weight' edge attribute,
        otherwise uses any valid edge attribute required.

    Returns
    -------
    nb : :class:`numpy.ndarray`
        The nodes' betweenness if `btype` is 'node' or 'both'
    eb : :class:`numpy.ndarray`
        The edges' betweenness if `btype` is 'edge' or 'both'

    References
    ----------
    .. [ig-ebetw] :igdoc:`edge_betweenness`
    .. [ig-nbetw] :igdoc:`betweenness`
    '''
    w = _get_ig_weights(g, weights)

    n  = g.node_nb()

    nb, eb = None, None

    if btype in ("both", "node"):
        di_nb = np.array(g.graph.betweenness(weights=w))
        nb    = np.array([di_nb[i] for i in g.get_nodes()])
        norm  = 1.

        if n > 2:
            norm = (1 if g.is_directed() else 2) / ((n - 1) * (n - 2))

        nb *= norm

    if btype in ("both", "edge"):
        eb = np.array(g.graph.edge_betweenness(weights=w))

        norm = (1 if g.is_directed() else 2) / (n * (n - 1))
        eb *= norm

    if btype == "node":
        return nb
    elif btype == "edge":
        return eb

    return nb, eb


def connected_components(g, ctype=None):
    '''
    Returns the connected component to which each node belongs.

    Parameters
    ----------
    g : :class:`~nngt.Graph`
        Graph to analyze.
    ctype : str, optional (default 'scc')
        Type of component that will be searched: either strongly connected
        ('scc', by default) or weakly connected ('wcc').

    Returns
    -------
    cc, hist : :class:`numpy.ndarray`
        The component associated to each node (`cc`) and the number of nodes in
        each of the component (`hist`).
        The components are numbered from 0.

    References
    ----------
    .. [ig-connected-components] :igdoc:`clusters`
    '''
    ctype   = "scc" if ctype is None else ctype
    ig_type = "strong"

    if ctype == "wcc":
        ig_type = "weak"
    elif ctype != "scc":
        raise ValueError("`ctype` must be either 'scc' or 'wcc'.")

    clusters = g.graph.clusters(ig_type)

    cc = np.zeros(g.node_nb(), dtype=int)

    for i, nodes in enumerate(clusters):
        cc[nodes] = i

    hist = np.array([len(c) for c in clusters], dtype=int)

    return cc, hist


def diameter(g, weights=None):
    '''
    Returns the diameter of the graph.

    It returns infinity if the graph is not connected (strongly connected for
    directed graphs).

    Parameters
    ----------
    g : :class:`~nngt.Graph`
        Graph to analyze.
    weights : bool or str, optional (default: binary edges)
        Whether edge weights should be considered; if ``None`` or ``False``
        then use binary edges; if ``True``, uses the 'weight' edge attribute,
        otherwise uses any valid edge attribute required.

    References
    ----------
    .. [ig-diameter] :igdoc:`diameter`
    '''
    ww = _get_ig_weights(g, weights)

    mode = "strong" if g.is_directed() else "weak"

    if not g.graph.is_connected(mode):
        return np.inf

    return g.graph.diameter(weights=ww)


def adj_mat(g, weights=None, mformat="csr"):
    r'''
    Returns the adjacency matrix :math:`A` of the graph.
    With edge :math:`i \leftarrow j` corresponding to entry :math:`A_{ij}`.

    Parameters
    ----------
    g : :class:`~nngt.Graph`
        Graph to analyze.
    weights : bool or str, optional (default: binary edges)
        Whether edge weights should be considered; if ``None`` or ``False``
        then returns the binary adjacency matrix; if ``True``, returns the
        weighted matrix, otherwise fills the matrix with any valid edge
        attribute values.
    mformat : str, optional (default: "csr")
        Type of :mod:`scipy.sparse` matrix that will be returned, by
        default :class:`scipy.sparse.csr_matrix`.

    Note
    ----
    This function does not use a builtin igraph method.

    Returns
    -------
    The adjacency matrix as a :class:`scipy.sparse.csr_matrix`.
    '''
    n = g.node_nb()

    w = _get_ig_weights(g, weights)

    if g.edge_nb():
        xs, ys = map(np.array, zip(*g.graph.get_edgelist()))
        xs, ys = xs.T, ys.T

        data = np.ones(xs.shape)

        if w is not None:
            data *= w

        coo_adj = ssp.coo_matrix((data, (xs, ys)), shape=(n, n))

        if not g.is_directed():
            coo_adj += coo_adj.T

        return coo_adj.asformat(mformat)

    m = ssp.cco_matrix((n, n))

    return m.asformat(mformat)


def get_edges(g):
    '''
    Returns the edges in the graph by order of creation.
    '''
    return g.graph.get_edgelist()

1	#-- coding:utf-8 --
2	#
3	# ig_functions.py
4	#
5	# This file is part of the NNGT project to generate and analyze
6	# neuronal networks and their activity.
7	# Copyright (C) 2015-2019 Tanguy Fardet
8	#
9	# This program is free software: you can redistribute it and/or modify
10	# it under the terms of the GNU General Public License as published by
11	# the Free Software Foundation, either version 3 of the License, or
12	# (at your option) any later version.
13	#
14	# This program is distributed in the hope that it will be useful,
15	# but WITHOUT ANY WARRANTY; without even the implied warranty of
16	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	# GNU General Public License for more details.
18	#
19	# You should have received a copy of the GNU General Public License
20	# along with this program. If not, see <http://www.gnu.org/licenses/>.
21
22	""" Tools to analyze graphs with the igraph backend """	2✔
23
24	import numpy as np	2✔
25	import scipy.sparse as ssp	2✔
26
27	from ..lib.test_functions import nonstring_container	2✔
28	from ..lib.graph_helpers import _get_ig_weights	2✔
29
30
31	def global_clustering(g, weights=None):	2✔
32	'''
33	Returns the undirected global clustering coefficient.
34	This corresponds to the ratio of undirected triangles to the number of
35	undirected triads.
36
37	Parameters
38	----------
39	g : :class:`~nngt.Graph`
40	Graph to analyze.
41	weights : bool or str, optional (default: binary edges)
42	Whether edge weights should be considered; if ``None`` or ``False``
43	then use binary edges; if ``True``, uses the 'weight' edge attribute,
44	otherwise uses any valid edge attribute required.
45
46	References
47	----------
48	.. [ig-global-clustering] :igdoc:`transitivity_undirected`
49	'''
50	ww = _get_ig_weights(g, weights)	1✔
51
52	if ww is not None:	1!
53	# raise warning
54	return np.average(	×
55	g.graph.as_undirected().transitivity_local_undirected(weights=ww))
56
57	return np.array(g.graph.as_undirected().transitivity_undirected())	1✔
58
59
60	def undirected_local_clustering(g, weights=None, nodes=None,	2✔
61	combine_weights="sum"):
62	'''
63	Returns the local clustering coefficient of some `nodes`.
64
65	Parameters
66	----------
67	g : :class:`~nngt.Graph`
68	Graph to analyze.
69	weights : bool or str, optional (default: binary edges)
70	Whether edge weights should be considered; if ``None`` or ``False``
71	then use binary edges; if ``True``, uses the 'weight' edge attribute,
72	otherwise uses any valid edge attribute required.
73	nodes : list, optional (default: all nodes)
74	The list of nodes for which the clutering will be returned
75	combine_weights : str, optional (default: "sum")
76	How the weights of directed edges between two nodes should be combined,
77	among:
78
79	* "sum": the sum of the edge attribute values will be used for the new
80	edge.
81	* "product": the product of the edge attribute values will be used for
82	the new edge.
83	* "mean": the mean of the edge attribute values will be used for the
84	new edge.
85	* "median": the median of the edge attribute values will be used for
86	the new edge.
87	* "min": the minimum of the edge attribute values will be used for the
88	new edge.
89	* "max": the maximum of the edge attribute values will be used for the
90	new edge.
91
92	Returns
93	-------
94	lc : :class:`numpy.ndarray`
95	The list of clustering coefficients, on per node.
96
97	References
98	----------
99	.. [ig-local-clustering] :igdoc:`transitivity_local_undirected`
100	'''
101	if weights is not None and not isinstance(weights, str):	2!
102	raise ValueError("Only existing attributes can be used as weights.")	×
103
104	u = g.graph.as_undirected(combine_edges=combine_weights)	2✔
105	u.simplify()	2✔
106
107	return np.array(u.transitivity_local_undirected(nodes, weights=weights))	2✔
108
109
110	def assortativity(g, degree, weights=None):	2✔
111	'''
112	Returns the assortativity of the graph.
113	This tells whether nodes are preferentially connected together depending
114	on their degree.
115
116	Parameters
117	----------
118	g : :class:`~nngt.Graph`
119	Graph to analyze.
120	degree : str
121	The type of degree that should be considered.
122	weights : bool or str, optional (default: binary edges)
123	Whether edge weights should be considered; if ``None`` or ``False``
124	then use binary edges; if ``True``, uses the 'weight' edge attribute,
125	otherwise uses any valid edge attribute required.
126
127	References
128	----------
129	.. [ig-assortativity] :igdoc:`assortativity`
130	'''
131	ww = _get_ig_weights(g, weights)	1✔
132
133	node_attr = g.get_degrees(degree, weights=ww)	1✔
134
135	return g.graph.assortativity(node_attr, directed=g.is_directed())	1✔
136
137
138	def reciprocity(g):	2✔
139	'''
140	Calculate the edge reciprocity of the graph.
141
142	The reciprocity is defined as the number of edges that have a reciprocal
143	edge (an edge between the same nodes but in the opposite direction)
144	divided by the total number of edges.
145	This is also the probability for any given edge, that its reciprocal edge
146	exists.
147	By definition, the reciprocity of undirected graphs is 1.
148
149	Parameters
150	----------
151	g : :class:`~nngt.Graph`
152	Graph to analyze.
153
154	References
155	----------
156	.. [ig-reciprocity] :igdoc:`reciprocity`
157	'''
158	return g.graph.reciprocity(ignore_loops=True, mode="default")	1✔
159
160
161	def closeness(g, weights=None, nodes=None, mode="out", harmonic=False,	2✔
162	default=np.NaN):
163	r'''
164	Returns the closeness centrality of some `nodes`.
165
166	Closeness centrality of a node `u` is defined, for the harmonic version,
167	as the sum of the reciprocal of the shortest path distance :math:`d_{uv}`
168	from `u` to the N - 1 other nodes in the graph (if `mode` is "out",
169	reciprocally :math:`d_{vu}`, the distance to `u` from another node v,
170	if `mode` is "in"):
171
172	.. math::
173
174	C(u) = \frac{1}{N - 1} \sum_{v \neq u} \frac{1}{d_{uv}},
175
176	or, using the arithmetic definition, as the reciprocal of the
177	average shortest path distance to/from `u` over to all other nodes:
178
179	.. math::
180
181	C(u) = \frac{n - 1}{\sum_{v \neq u} d_{uv}},
182
183	where `d_{uv}` is the shortest-path distance from `u` to `v`,
184	and `n` is the number of nodes in the strongly-connected component (SCC).
185
186	By definition, the distance is infinite when nodes are not connected by
187	a path in the harmonic case (such that :math:`\frac{1}{d(v, u)} = 0`),
188	while the distance itself is taken as zero for unconnected nodes in the
189	first equation.
190
191	Parameters
192	----------
193	g : :class:`~nngt.Graph`
194	Graph to analyze.
195	weights : bool or str, optional (default: binary edges)
196	Whether edge weights should be considered; if ``None`` or ``False``
197	then use binary edges; if ``True``, uses the 'weight' edge attribute,
198	otherwise uses any valid edge attribute required.
199	nodes : list, optional (default: all nodes)
200	The list of nodes for which the clutering will be returned
201	mode : str, optional (default: "out")
202	For directed graphs, whether the distances are computed from ("out") or
203	to ("in") each of the nodes.
204	harmonic : bool, optional (default: False)
205	Whether the arithmetic (default) or the harmonic (recommended) version
206	of the closeness should be used.
207
208	Returns
209	-------
210	c : :class:`numpy.ndarray`
211	The list of closeness centralities, on per node.
212
213	.. warning ::
214	For compatibility reasons (harmonic closeness is not implemented for
215	igraph), the arithmetic version is used by default; however, it is
216	recommended to use the harmonic version instead whenever possible.
217
218	Note
219	----
220	When requesting a subset of nodes, check whether it is faster to use
221	`nodes`, or to compute all closeness centralities, then take the subset.
222
223	References
224	----------
225	.. [ig-closeness] :igdoc:`closeness`
226	'''
227	if harmonic:	1✔
228	raise NotImplementedError("`harmonic` closeness is not available with "
229	"igraph backend.")
230
231	if not np.all(g.get_degrees("in")) or not np.all(g.get_degrees("out")):	1✔
232	raise RuntimeError("igraph backend does not support closeness for "	1✔
233	"graphs containing nodes with zero in/out-degree.")
234
235	ww = _get_ig_weights(g, weights)	1✔
236
237	return g.graph.closeness(nodes, mode=mode, weights=ww)	1✔
238
239
240	def betweenness(g, btype="both", weights=None):	2✔
241	'''
242	Returns the normalized betweenness centrality of the nodes and edges.
243
244	Parameters
245	----------
246	g : :class:`~nngt.Graph`
247	Graph to analyze.
248	ctype : str, optional (default 'both')
249	The centrality that should be returned (either 'node', 'edge', or
250	'both'). By default, both betweenness centralities are computed.
251	weights : bool or str, optional (default: binary edges)
252	Whether edge weights should be considered; if ``None`` or ``False``
253	then use binary edges; if ``True``, uses the 'weight' edge attribute,
254	otherwise uses any valid edge attribute required.
255
256	Returns
257	-------
258	nb : :class:`numpy.ndarray`
259	The nodes' betweenness if `btype` is 'node' or 'both'
260	eb : :class:`numpy.ndarray`
261	The edges' betweenness if `btype` is 'edge' or 'both'
262
263	References
264	----------
265	.. [ig-ebetw] :igdoc:`edge_betweenness`
266	.. [ig-nbetw] :igdoc:`betweenness`
267	'''
268	w = _get_ig_weights(g, weights)	2✔
269
270	n = g.node_nb()	2✔
271
272	nb, eb = None, None	2✔
273
274	if btype in ("both", "node"):	2✔
275	di_nb = np.array(g.graph.betweenness(weights=w))	2✔
276	nb = np.array([di_nb[i] for i in g.get_nodes()])	2✔
277	norm = 1.	2✔
278
279	if n > 2:	2!
280	norm = (1 if g.is_directed() else 2) / ((n - 1) * (n - 2))	2✔
281
282	nb *= norm	2✔
283
284	if btype in ("both", "edge"):	2✔
285	eb = np.array(g.graph.edge_betweenness(weights=w))	2✔
286
287	norm = (1 if g.is_directed() else 2) / (n * (n - 1))	2✔
288	eb *= norm	2✔
289
290	if btype == "node":	2✔
291	return nb	1✔
292	elif btype == "edge":	2✔
293	return eb	1✔
294
295	return nb, eb	2✔
296
297
298	def connected_components(g, ctype=None):	2✔
299	'''
300	Returns the connected component to which each node belongs.
301
302	Parameters
303	----------
304	g : :class:`~nngt.Graph`
305	Graph to analyze.
306	ctype : str, optional (default 'scc')
307	Type of component that will be searched: either strongly connected
308	('scc', by default) or weakly connected ('wcc').
309
310	Returns
311	-------
312	cc, hist : :class:`numpy.ndarray`
313	The component associated to each node (`cc`) and the number of nodes in
314	each of the component (`hist`).
315	The components are numbered from 0.
316
317	References
318	----------
319	.. [ig-connected-components] :igdoc:`clusters`
320	'''
321	ctype = "scc" if ctype is None else ctype	1✔
322	ig_type = "strong"	1✔
323
324	if ctype == "wcc":	1✔
325	ig_type = "weak"	1✔
326	elif ctype != "scc":	1!
327	raise ValueError("`ctype` must be either 'scc' or 'wcc'.")	×
328
329	clusters = g.graph.clusters(ig_type)	1✔
330
331	cc = np.zeros(g.node_nb(), dtype=int)	1✔
332
333	for i, nodes in enumerate(clusters):	1✔
334	cc[nodes] = i	1✔
335
336	hist = np.array([len(c) for c in clusters], dtype=int)	1✔
337
338	return cc, hist	1✔
339
340
341	def diameter(g, weights=None):	2✔
342	'''
343	Returns the diameter of the graph.
344
345	It returns infinity if the graph is not connected (strongly connected for
346	directed graphs).
347
348	Parameters
349	----------
350	g : :class:`~nngt.Graph`
351	Graph to analyze.
352	weights : bool or str, optional (default: binary edges)
353	Whether edge weights should be considered; if ``None`` or ``False``
354	then use binary edges; if ``True``, uses the 'weight' edge attribute,
355	otherwise uses any valid edge attribute required.
356
357	References
358	----------
359	.. [ig-diameter] :igdoc:`diameter`
360	'''
361	ww = _get_ig_weights(g, weights)	1✔
362
363	mode = "strong" if g.is_directed() else "weak"	1✔
364
365	if not g.graph.is_connected(mode):	1✔
366	return np.inf	1✔
367
368	return g.graph.diameter(weights=ww)	1✔
369
370
371	def adj_mat(g, weights=None, mformat="csr"):	2✔
372	r'''
373	Returns the adjacency matrix :math:`A` of the graph.
374	With edge :math:`i \leftarrow j` corresponding to entry :math:`A_{ij}`.
375
376	Parameters
377	----------
378	g : :class:`~nngt.Graph`
379	Graph to analyze.
380	weights : bool or str, optional (default: binary edges)
381	Whether edge weights should be considered; if ``None`` or ``False``
382	then returns the binary adjacency matrix; if ``True``, returns the
383	weighted matrix, otherwise fills the matrix with any valid edge
384	attribute values.
385	mformat : str, optional (default: "csr")
386	Type of :mod:`scipy.sparse` matrix that will be returned, by
387	default :class:`scipy.sparse.csr_matrix`.
388
389	Note
390	----
391	This function does not use a builtin igraph method.
392
393	Returns
394	-------
395	The adjacency matrix as a :class:`scipy.sparse.csr_matrix`.
396	'''
397	n = g.node_nb()	1✔
398
399	w = _get_ig_weights(g, weights)	1✔
400
401	if g.edge_nb():	1!
402	xs, ys = map(np.array, zip(*g.graph.get_edgelist()))	1✔
403	xs, ys = xs.T, ys.T	1✔
404
405	data = np.ones(xs.shape)	1✔
406
407	if w is not None:	1✔
408	data *= w	1✔
409
410	coo_adj = ssp.coo_matrix((data, (xs, ys)), shape=(n, n))	1✔
411
412	if not g.is_directed():	1✔
413	coo_adj += coo_adj.T	1✔
414
415	return coo_adj.asformat(mformat)	1✔
416
417	m = ssp.cco_matrix((n, n))	×
418
419	return m.asformat(mformat)	×
420
421
422	def get_edges(g):	2✔
423	'''
424	Returns the edges in the graph by order of creation.
425	'''
426	return g.graph.get_edgelist()	×

Silmathoron / NNGT / 823

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous