<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>attr_matrix — NetworkX 1.8.1 documentation</title>
<link rel="stylesheet" href="../../_static/networkx.css" type="text/css" />
<link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../../',
VERSION: '1.8.1',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: false
};
</script>
<script type="text/javascript" src="../../_static/jquery.js"></script>
<script type="text/javascript" src="../../_static/underscore.js"></script>
<script type="text/javascript" src="../../_static/doctools.js"></script>
<link rel="search" type="application/opensearchdescription+xml"
title="Search within NetworkX 1.8.1 documentation"
href="../../_static/opensearch.xml"/>
<link rel="top" title="NetworkX 1.8.1 documentation" href="../../index.html" />
<link rel="up" title="Linear algebra" href="../linalg.html" />
<link rel="next" title="attr_sparse_matrix" href="networkx.linalg.attrmatrix.attr_sparse_matrix.html" />
<link rel="prev" title="adjacency_spectrum" href="networkx.linalg.spectrum.adjacency_spectrum.html" />
</head>
<body>
<div style="color: black;background-color: white; font-size: 3.2em; text-align: left; padding: 15px 10px 10px 15px">
NetworkX
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="../../py-modindex.html" title="Python Module Index"
>modules</a> |</li>
<li class="right" >
<a href="networkx.linalg.attrmatrix.attr_sparse_matrix.html" title="attr_sparse_matrix"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="networkx.linalg.spectrum.adjacency_spectrum.html" title="adjacency_spectrum"
accesskey="P">previous</a> |</li>
<li><a href="http://networkx.github.com/">NetworkX Home </a> | </li>
<li><a href="http://networkx.github.com/documentation.html">Documentation </a>| </li>
<li><a href="http://networkx.github.com/download.html">Download </a> | </li>
<li><a href="http://github.com/networkx">Developer (Github)</a></li>
<li><a href="../index.html" >Reference</a> »</li>
<li><a href="../pdf_reference.html" >Reference</a> »</li>
<li><a href="../linalg.html" accesskey="U">Linear algebra</a> »</li>
</ul>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h4>Previous topic</h4>
<p class="topless"><a href="networkx.linalg.spectrum.adjacency_spectrum.html"
title="previous chapter">adjacency_spectrum</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="networkx.linalg.attrmatrix.attr_sparse_matrix.html"
title="next chapter">attr_sparse_matrix</a></p>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="../../search.html" method="get">
<input type="text" name="q" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="attr-matrix">
<h1>attr_matrix<a class="headerlink" href="#attr-matrix" title="Permalink to this headline">¶</a></h1>
<dl class="function">
<dt id="networkx.linalg.attrmatrix.attr_matrix">
<tt class="descname">attr_matrix</tt><big>(</big><em>G</em>, <em>edge_attr=None</em>, <em>node_attr=None</em>, <em>normalized=False</em>, <em>rc_order=None</em>, <em>dtype=None</em>, <em>order=None</em><big>)</big><a class="reference internal" href="../../_modules/networkx/linalg/attrmatrix.html#attr_matrix"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#networkx.linalg.attrmatrix.attr_matrix" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a NumPy matrix using attributes from G.</p>
<p>If only <span class="math">G</span> is passed in, then the adjacency matrix is constructed.</p>
<p>Let A be a discrete set of values for the node attribute <span class="math">node_attr</span>. Then
the elements of A represent the rows and columns of the constructed matrix.
Now, iterate through every edge e=(u,v) in <span class="math">G</span> and consider the value
of the edge attribute <span class="math">edge_attr</span>. If ua and va are the values of the
node attribute <span class="math">node_attr</span> for u and v, respectively, then the value of
the edge attribute is added to the matrix element at (ua, va).</p>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Parameters :</th><td class="field-body"><p class="first"><strong>G</strong> : graph</p>
<blockquote>
<div><p>The NetworkX graph used to construct the NumPy matrix.</p>
</div></blockquote>
<p><strong>edge_attr</strong> : str, optional</p>
<blockquote>
<div><p>Each element of the matrix represents a running total of the
specified edge attribute for edges whose node attributes correspond
to the rows/cols of the matirx. The attribute must be present for
all edges in the graph. If no attribute is specified, then we
just count the number of edges whose node attributes correspond
to the matrix element.</p>
</div></blockquote>
<p><strong>node_attr</strong> : str, optional</p>
<blockquote>
<div><p>Each row and column in the matrix represents a particular value
of the node attribute. The attribute must be present for all nodes
in the graph. Note, the values of this attribute should be reliably
hashable. So, float values are not recommended. If no attribute is
specified, then the rows and columns will be the nodes of the graph.</p>
</div></blockquote>
<p><strong>normalized</strong> : bool, optional</p>
<blockquote>
<div><p>If True, then each row is normalized by the summation of its values.</p>
</div></blockquote>
<p><strong>rc_order</strong> : list, optional</p>
<blockquote>
<div><p>A list of the node attribute values. This list specifies the ordering
of rows and columns of the array. If no ordering is provided, then
the ordering will be random (and also, a return value).</p>
</div></blockquote>
</td>
</tr>
<tr class="field-even field"><th class="field-name">Returns :</th><td class="field-body"><p class="first"><strong>M</strong> : NumPy matrix</p>
<blockquote>
<div><p>The attribute matrix.</p>
</div></blockquote>
<p><strong>ordering</strong> : list</p>
<blockquote>
<div><p>If <span class="math">rc_order</span> was specified, then only the matrix is returned.
However, if <span class="math">rc_order</span> was None, then the ordering used to construct
the matrix is returned as well.</p>
</div></blockquote>
</td>
</tr>
<tr class="field-odd field"><th class="field-name" colspan="2">Other Parameters:</th></tr>
<tr class="field-odd field"><td> </td><td class="field-body"><p class="first"><strong>dtype</strong> : NumPy data-type, optional</p>
<blockquote>
<div><p>A valid NumPy dtype used to initialize the array. Keep in mind certain
dtypes can yield unexpected results if the array is to be normalized.
The parameter is passed to numpy.zeros(). If unspecified, the NumPy
default is used.</p>
</div></blockquote>
<p><strong>order</strong> : {‘C’, ‘F’}, optional</p>
<blockquote class="last">
<div><p>Whether to store multidimensional data in C- or Fortran-contiguous
(row- or column-wise) order in memory. This parameter is passed to
numpy.zeros(). If unspecified, the NumPy default is used.</p>
</div></blockquote>
</td>
</tr>
</tbody>
</table>
<p class="rubric">Examples</p>
<p>Construct an adjacency matrix:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">G</span> <span class="o">=</span> <span class="n">nx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edge</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="n">thickness</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span><span class="n">weight</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edge</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="n">thickness</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">add_edge</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="n">thickness</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">nx</span><span class="o">.</span><span class="n">attr_matrix</span><span class="p">(</span><span class="n">G</span><span class="p">,</span> <span class="n">rc_order</span><span class="o">=</span><span class="p">[</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">])</span>
<span class="go">matrix([[ 0., 1., 1.],</span>
<span class="go"> [ 1., 0., 1.],</span>
<span class="go"> [ 1., 1., 0.]])</span>
</pre></div>
</div>
<p>Alternatively, we can obtain the matrix describing edge thickness.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">nx</span><span class="o">.</span><span class="n">attr_matrix</span><span class="p">(</span><span class="n">G</span><span class="p">,</span> <span class="n">edge_attr</span><span class="o">=</span><span class="s">'thickness'</span><span class="p">,</span> <span class="n">rc_order</span><span class="o">=</span><span class="p">[</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">])</span>
<span class="go">matrix([[ 0., 1., 2.],</span>
<span class="go"> [ 1., 0., 3.],</span>
<span class="go"> [ 2., 3., 0.]])</span>
</pre></div>
</div>
<p>We can also color the nodes and ask for the probability distribution over
all edges (u,v) describing:</p>
<blockquote>
<div>Pr(v has color Y | u has color X)</div></blockquote>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">node</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="s">'color'</span><span class="p">]</span> <span class="o">=</span> <span class="s">'red'</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">node</span><span class="p">[</span><span class="mi">1</span><span class="p">][</span><span class="s">'color'</span><span class="p">]</span> <span class="o">=</span> <span class="s">'red'</span>
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">node</span><span class="p">[</span><span class="mi">2</span><span class="p">][</span><span class="s">'color'</span><span class="p">]</span> <span class="o">=</span> <span class="s">'blue'</span>
<span class="gp">>>> </span><span class="n">rc</span> <span class="o">=</span> <span class="p">[</span><span class="s">'red'</span><span class="p">,</span> <span class="s">'blue'</span><span class="p">]</span>
<span class="gp">>>> </span><span class="n">nx</span><span class="o">.</span><span class="n">attr_matrix</span><span class="p">(</span><span class="n">G</span><span class="p">,</span> <span class="n">node_attr</span><span class="o">=</span><span class="s">'color'</span><span class="p">,</span> <span class="n">normalized</span><span class="o">=</span><span class="bp">True</span><span class="p">,</span> <span class="n">rc_order</span><span class="o">=</span><span class="n">rc</span><span class="p">)</span>
<span class="go">matrix([[ 0.33333333, 0.66666667],</span>
<span class="go"> [ 1. , 0. ]])</span>
</pre></div>
</div>
<p>For example, the above tells us that for all edges (u,v):</p>
<blockquote>
<div><p>Pr( v is red | u is red) = 1/3
Pr( v is blue | u is red) = 2/3</p>
<p>Pr( v is red | u is blue) = 1
Pr( v is blue | u is blue) = 0</p>
</div></blockquote>
<p>Finally, we can obtain the total weights listed by the node colors.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">nx</span><span class="o">.</span><span class="n">attr_matrix</span><span class="p">(</span><span class="n">G</span><span class="p">,</span> <span class="n">edge_attr</span><span class="o">=</span><span class="s">'weight'</span><span class="p">,</span> <span class="n">node_attr</span><span class="o">=</span><span class="s">'color'</span><span class="p">,</span> <span class="n">rc_order</span><span class="o">=</span><span class="n">rc</span><span class="p">)</span>
<span class="go">matrix([[ 3., 2.],</span>
<span class="go"> [ 2., 0.]])</span>
</pre></div>
</div>
<p>Thus, the total weight over all edges (u,v) with u and v having colors:</p>
<blockquote>
<div>(red, red) is 3 # the sole contribution is from edge (0,1)
(red, blue) is 2 # contributions from edges (0,2) and (1,2)
(blue, red) is 2 # same as (red, blue) since graph is undirected
(blue, blue) is 0 # there are no edges with blue endpoints</div></blockquote>
</dd></dl>
</div>
</div>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="../../py-modindex.html" title="Python Module Index"
>modules</a> |</li>
<li class="right" >
<a href="networkx.linalg.attrmatrix.attr_sparse_matrix.html" title="attr_sparse_matrix"
>next</a> |</li>
<li class="right" >
<a href="networkx.linalg.spectrum.adjacency_spectrum.html" title="adjacency_spectrum"
>previous</a> |</li>
<li><a href="http://networkx.github.com/">NetworkX Home </a> | </li>
<li><a href="http://networkx.github.com/documentation.html">Documentation </a>| </li>
<li><a href="http://networkx.github.com/download.html">Download </a> | </li>
<li><a href="http://github.com/networkx">Developer (Github)</a></li>
<li><a href="../index.html" >Reference</a> »</li>
<li><a href="../pdf_reference.html" >Reference</a> »</li>
<li><a href="../linalg.html" >Linear algebra</a> »</li>
</ul>
</div>
<div class="footer">
© Copyright 2013, NetworkX Developers.
Last updated on Oct 23, 2013.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
</div>
</body>
</html>
