daviddoji/numpy-100
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Nicolas Rougier
2014-05-27 06:10:33 +02:00
commit 86a42b05b1
6 changed files with 1369 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
Makefile Normal file
View File

@@ -0,0 +1,35 @@
MAKE = /usr/bin/make
RST2HTML = rst2html.py
RST2LATEX = rst2latex.py
STYLESHEET = numpy.css
RST2HTML_OPTIONS = --strip-comments \
--report=3 \
--stylesheet=$(STYLESHEET) \
--link-stylesheet
RST2LATEX_OPTIONS = --strip-comments \
--report=3 \
--use-latex-toc
SOURCES = $(wildcard *.rst)
HTML_OBJECTS = $(subst .rst,.html, $(SOURCES))
LATEX_OBJECTS = $(subst .rst,.tex, $(SOURCES))
html: $(HTML_OBJECTS)
latex: $(LATEX_OBJECTS)
%.html: %.rst Makefile
@echo " - $@"
@$(RST2HTML) $(RST2HTML_OPTIONS) $< $@
%.tex: %.rst Makefile
@echo " - $@"
@$(RST2LATEX) $(RST2LATEX_OPTIONS) $< $@
clean:
@-rm -f $(LATEX_OBJECTS) $(HTML_OBJECTS)
distclean: clean
@-rm -f `find . -name "*~"`

27
README.txt Normal file
View File

@@ -0,0 +1,27 @@
100 Numpy exercices
===================
The goal is both to offer a quick reference for new and old users and to
provide also a set of exercices for those who teach.
If you remember having asked or answered a (short) problem, you can send a pull
request. The format is:
#. Find indices of non-zero elements from [1,2,0,0,4,0]
.. code:: python
# Author: Somebody
print np.nonzero([1,2,0,0,4,0])
If you can provide the assumed level of the answer, that would be even better.
Here is what the page looks like so far:
http://www.loria.fr/~rougier/teaching/numpy.100/index.html
(The level names came from an old-game: Dungeon Master)

435
index.html Normal file
View File

@@ -0,0 +1,435 @@
<?xml version="1.0" encoding="utf-8" ?>
<!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" xml:lang="en" lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta name="generator" content="Docutils 0.11: http://docutils.sourceforge.net/" />
<title>100 numpy exercises</title>
<link rel="stylesheet" href="numpy.css" type="text/css" />
</head>
<body>
<div class="document" id="numpy-exercises">
<h1 class="title">100 numpy exercises</h1>
<h2 class="subtitle" id="a-joint-effort-of-the-numpy-community">A joint effort of the numpy community</h2>
<div class="contents local topic" id="contents">
<ul class="simple">
<li><a class="reference internal" href="#neophyte" id="id1">Neophyte</a></li>
<li><a class="reference internal" href="#novice" id="id2">Novice</a></li>
<li><a class="reference internal" href="#apprentice" id="id3">Apprentice</a></li>
<li><a class="reference internal" href="#journeyman" id="id4">Journeyman</a></li>
<li><a class="reference internal" href="#craftsman" id="id5">Craftsman</a></li>
<li><a class="reference internal" href="#artisan" id="id6">Artisan</a></li>
<li><a class="reference internal" href="#adept" id="id7">Adept</a></li>
<li><a class="reference internal" href="#expert" id="id8">Expert</a></li>
<li><a class="reference internal" href="#master" id="id9">Master</a></li>
<li><a class="reference internal" href="#archmaster" id="id10">Archmaster</a></li>
</ul>
</div>
<div class="section" id="neophyte">
<h1><a class="toc-backref" href="#id1">Neophyte</a></h1>
<ol class="arabic">
<li><p class="first">Import the numpy package under the name <tt class="docutils literal">np</tt></p>
<pre class="code python literal-block">
<span class="keyword namespace">import</span> <span class="name namespace">numpy</span> <span class="keyword namespace">as</span> <span class="name namespace">np</span>
</pre>
</li>
<li><p class="first">Print the numpy version and the configuration.</p>
<pre class="code python literal-block">
<span class="keyword">print</span> <span class="name">np</span><span class="operator">.</span><span class="name">__version__</span>
<span class="name">np</span><span class="operator">.</span><span class="name">__config__</span><span class="operator">.</span><span class="name">show</span><span class="punctuation">()</span>
</pre>
</li>
<li><p class="first">Create a null vector of size 10</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">zeros</span><span class="punctuation">(</span><span class="literal number integer">10</span><span class="punctuation">)</span>
</pre>
</li>
<li><p class="first">Create a null vector of size 10 but the fifth value which is 1</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">zeros</span><span class="punctuation">(</span><span class="literal number integer">10</span><span class="punctuation">)</span>
<span class="name">Z</span><span class="punctuation">[</span><span class="literal number integer">4</span><span class="punctuation">]</span> <span class="operator">=</span> <span class="literal number integer">1</span>
</pre>
</li>
<li><p class="first">Create a vector with values ranging from 10 to 99</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">arange</span><span class="punctuation">(</span><span class="literal number integer">10</span><span class="punctuation">,</span><span class="literal number integer">100</span><span class="punctuation">)</span>
</pre>
</li>
<li><p class="first">Create a 3x3 matrix with values ranging from 0 to 8</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">arange</span><span class="punctuation">(</span><span class="literal number integer">9</span><span class="punctuation">)</span><span class="operator">.</span><span class="name">reshape</span><span class="punctuation">(</span><span class="literal number integer">3</span><span class="punctuation">,</span><span class="literal number integer">3</span><span class="punctuation">)</span>
</pre>
</li>
<li><p class="first">Find indices of non-zero elements from [1,2,0,0,4,0]</p>
<pre class="code python literal-block">
<span class="name">nz</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">nonzero</span><span class="punctuation">([</span><span class="literal number integer">1</span><span class="punctuation">,</span><span class="literal number integer">2</span><span class="punctuation">,</span><span class="literal number integer">0</span><span class="punctuation">,</span><span class="literal number integer">0</span><span class="punctuation">,</span><span class="literal number integer">4</span><span class="punctuation">,</span><span class="literal number integer">0</span><span class="punctuation">])</span>
</pre>
</li>
<li><p class="first">Declare a 3x3 identity matrix</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">eye</span><span class="punctuation">(</span><span class="literal number integer">3</span><span class="punctuation">)</span>
</pre>
</li>
<li><p class="first">Declare a 5x5 matrix with values 1,2,3,4 just below the diagonal</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">diag</span><span class="punctuation">(</span><span class="literal number integer">1</span><span class="operator">+</span><span class="name">np</span><span class="operator">.</span><span class="name">arange</span><span class="punctuation">(</span><span class="literal number integer">4</span><span class="punctuation">),</span><span class="name">k</span><span class="operator">=-</span><span class="literal number integer">1</span><span class="punctuation">)</span>
</pre>
</li>
<li><p class="first">Declare a 10x10x10 array with random values</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">random</span><span class="operator">.</span><span class="name">random</span><span class="punctuation">((</span><span class="literal number integer">10</span><span class="punctuation">,</span><span class="literal number integer">10</span><span class="punctuation">,</span><span class="literal number integer">10</span><span class="punctuation">))</span>
</pre>
</li>
</ol>
</div>
<div class="section" id="novice">
<h1><a class="toc-backref" href="#id2">Novice</a></h1>
<ol class="arabic">
<li><p class="first">Declare a 8x8 matrix and fill it with a checkerboard pattern</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">zeros</span><span class="punctuation">((</span><span class="literal number integer">8</span><span class="punctuation">,</span><span class="literal number integer">8</span><span class="punctuation">))</span>
<span class="name">Z</span><span class="punctuation">[</span><span class="literal number integer">1</span><span class="punctuation">::</span><span class="literal number integer">2</span><span class="punctuation">,::</span><span class="literal number integer">2</span><span class="punctuation">]</span> <span class="operator">=</span> <span class="literal number integer">1</span>
<span class="name">Z</span><span class="punctuation">[::</span><span class="literal number integer">2</span><span class="punctuation">,</span><span class="literal number integer">1</span><span class="punctuation">::</span><span class="literal number integer">2</span><span class="punctuation">]</span> <span class="operator">=</span> <span class="literal number integer">1</span>
</pre>
</li>
<li><p class="first">Declare a 10x10 array with random values and find the minimum and maximum values</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">random</span><span class="operator">.</span><span class="name">random</span><span class="punctuation">((</span><span class="literal number integer">10</span><span class="punctuation">,</span><span class="literal number integer">10</span><span class="punctuation">))</span>
<span class="name">Zmin</span><span class="punctuation">,</span> <span class="name">Zmax</span> <span class="operator">=</span> <span class="name">Z</span><span class="operator">.</span><span class="name">min</span><span class="punctuation">(),</span> <span class="name">Z</span><span class="operator">.</span><span class="name">max</span><span class="punctuation">()</span>
</pre>
</li>
<li><p class="first">Create a checkerboard 8x8 matrix using the tile function</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">tile</span><span class="punctuation">(</span> <span class="name">np</span><span class="operator">.</span><span class="name">array</span><span class="punctuation">([[</span><span class="literal number integer">0</span><span class="punctuation">,</span><span class="literal number integer">1</span><span class="punctuation">],[</span><span class="literal number integer">1</span><span class="punctuation">,</span><span class="literal number integer">0</span><span class="punctuation">]]),</span> <span class="punctuation">(</span><span class="literal number integer">4</span><span class="punctuation">,</span><span class="literal number integer">4</span><span class="punctuation">))</span>
</pre>
</li>
<li><p class="first">Normalize a 5x5 random matrix (between 0 and 1)</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">random</span><span class="operator">.</span><span class="name">random</span><span class="punctuation">((</span><span class="literal number integer">5</span><span class="punctuation">,</span><span class="literal number integer">5</span><span class="punctuation">))</span>
<span class="name">Zmax</span><span class="punctuation">,</span><span class="name">Zmin</span> <span class="operator">=</span> <span class="name">Z</span><span class="operator">.</span><span class="name">max</span><span class="punctuation">(),</span> <span class="name">Z</span><span class="operator">.</span><span class="name">min</span><span class="punctuation">()</span>
<span class="name">Z</span> <span class="operator">=</span> <span class="punctuation">(</span><span class="name">Z</span> <span class="operator">-</span> <span class="name">Zmin</span><span class="punctuation">)</span><span class="operator">/</span><span class="punctuation">(</span><span class="name">Zmax</span> <span class="operator">-</span> <span class="name">Zmin</span><span class="punctuation">)</span>
</pre>
</li>
<li><p class="first">Multiply a 5x3 matrix by a 3x2 matrix (real matrix product)</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">dot</span><span class="punctuation">(</span><span class="name">np</span><span class="operator">.</span><span class="name">ones</span><span class="punctuation">((</span><span class="literal number integer">5</span><span class="punctuation">,</span><span class="literal number integer">3</span><span class="punctuation">)),</span> <span class="name">np</span><span class="operator">.</span><span class="name">ones</span><span class="punctuation">((</span><span class="literal number integer">3</span><span class="punctuation">,</span><span class="literal number integer">2</span><span class="punctuation">)))</span>
</pre>
</li>
<li><p class="first">Create a 10x10 matrix with row values ranging from 0 to 9</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">zeros</span><span class="punctuation">((</span><span class="literal number integer">10</span><span class="punctuation">,</span><span class="literal number integer">10</span><span class="punctuation">))</span>
<span class="name">Z</span> <span class="operator">+=</span> <span class="name">np</span><span class="operator">.</span><span class="name">arange</span><span class="punctuation">(</span><span class="literal number integer">10</span><span class="punctuation">)</span>
</pre>
</li>
<li><p class="first">Create a vector of size 1000 with values ranging from 0 to 1, both excluded</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">random</span><span class="operator">.</span><span class="name">linspace</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span><span class="literal number integer">1</span><span class="punctuation">,</span><span class="literal number integer">1002</span><span class="punctuation">,</span><span class="name">endpoint</span><span class="operator">=</span><span class="name builtin pseudo">True</span><span class="punctuation">)[</span><span class="literal number integer">1</span><span class="punctuation">:</span><span class="operator">-</span><span class="literal number integer">1</span><span class="punctuation">]</span>
</pre>
</li>
<li><p class="first">Create a random vector of size 100 and sort it</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">random</span><span class="operator">.</span><span class="name">random</span><span class="punctuation">(</span><span class="literal number integer">100</span><span class="punctuation">)</span>
<span class="name">Z</span><span class="operator">.</span><span class="name">sort</span><span class="punctuation">()</span>
</pre>
</li>
<li><p class="first">Consider two random matrices A anb B, check if they are equal.</p>
<pre class="code python literal-block">
<span class="name">A</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">random</span><span class="operator">.</span><span class="name">randint</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span><span class="literal number integer">2</span><span class="punctuation">,(</span><span class="literal number integer">2</span><span class="punctuation">,</span><span class="literal number integer">2</span><span class="punctuation">))</span>
<span class="name">B</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">random</span><span class="operator">.</span><span class="name">randint</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span><span class="literal number integer">2</span><span class="punctuation">,(</span><span class="literal number integer">2</span><span class="punctuation">,</span><span class="literal number integer">2</span><span class="punctuation">))</span>
<span class="name">equal</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">allclose</span><span class="punctuation">(</span><span class="name">A</span><span class="punctuation">,</span><span class="name">B</span><span class="punctuation">)</span>
</pre>
</li>
<li><p class="first">Create a random vector of size 1000 and find the mean value</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">random</span><span class="operator">.</span><span class="name">random</span><span class="punctuation">(</span><span class="literal number integer">1000</span><span class="punctuation">)</span>
<span class="name">m</span> <span class="operator">=</span> <span class="name">Z</span><span class="operator">.</span><span class="name">mean</span><span class="punctuation">()</span>
</pre>
</li>
</ol>
</div>
<div class="section" id="apprentice">
<h1><a class="toc-backref" href="#id3">Apprentice</a></h1>
<ol class="arabic">
<li><p class="first">Make an array immutable</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">zeros</span><span class="punctuation">(</span><span class="literal number integer">10</span><span class="punctuation">)</span>
<span class="name">Z</span><span class="operator">.</span><span class="name">flags</span><span class="operator">.</span><span class="name">writeable</span> <span class="operator">=</span> <span class="name builtin pseudo">False</span>
</pre>
</li>
<li><p class="first">Consider a random 100x2 matrix representing cartesian coordinates, convert
them to polar coordinates</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">random</span><span class="operator">.</span><span class="name">random</span><span class="punctuation">((</span><span class="literal number integer">100</span><span class="punctuation">,</span><span class="literal number integer">2</span><span class="punctuation">))</span>
<span class="name">X</span><span class="punctuation">,</span><span class="name">Y</span> <span class="operator">=</span> <span class="name">Z</span><span class="punctuation">[:,</span><span class="literal number integer">0</span><span class="punctuation">],</span> <span class="name">Z</span><span class="punctuation">[:,</span><span class="literal number integer">1</span><span class="punctuation">]</span>
<span class="name">R</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">sqrt</span><span class="punctuation">(</span><span class="name">X</span><span class="operator">**</span><span class="literal number integer">2</span><span class="operator">+</span><span class="name">Y</span><span class="operator">**</span><span class="literal number integer">2</span><span class="punctuation">)</span>
<span class="name">T</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">arctan2</span><span class="punctuation">(</span><span class="name">Y</span><span class="punctuation">,</span><span class="name">X</span><span class="punctuation">)</span>
</pre>
</li>
<li><p class="first">Create random vector of size 100 and replace the maximum value by 0</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">random</span><span class="operator">.</span><span class="name">random</span><span class="punctuation">(</span><span class="literal number integer">100</span><span class="punctuation">)</span>
<span class="name">Z</span><span class="punctuation">[</span><span class="name">Z</span><span class="operator">.</span><span class="name">argmax</span><span class="punctuation">()]</span> <span class="operator">=</span> <span class="literal number integer">0</span>
</pre>
</li>
<li><p class="first">Declare a structured array with <tt class="docutils literal">x</tt> and <tt class="docutils literal">y</tt> coordinates covering the
[0,1]x[0,1] area.</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">zeros</span><span class="punctuation">((</span><span class="literal number integer">10</span><span class="punctuation">,</span><span class="literal number integer">10</span><span class="punctuation">),</span> <span class="punctuation">[(</span><span class="literal string">'x'</span><span class="punctuation">,</span><span class="name builtin">float</span><span class="punctuation">),(</span><span class="literal string">'y'</span><span class="punctuation">,</span><span class="name builtin">float</span><span class="punctuation">)])</span>
<span class="name">Z</span><span class="punctuation">[</span><span class="literal string">'x'</span><span class="punctuation">],</span> <span class="name">Z</span><span class="punctuation">[</span><span class="literal string">'y'</span><span class="punctuation">]</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">meshgrid</span><span class="punctuation">(</span><span class="name">np</span><span class="operator">.</span><span class="name">linspace</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span><span class="literal number integer">1</span><span class="punctuation">,</span><span class="literal number integer">10</span><span class="punctuation">),</span>
<span class="name">np</span><span class="operator">.</span><span class="name">linspace</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span><span class="literal number integer">1</span><span class="punctuation">,</span><span class="literal number integer">10</span><span class="punctuation">))</span>
</pre>
</li>
<li><p class="first">Print the minimum and maximum representable value for each numpy scalar type</p>
<pre class="code python literal-block">
<span class="keyword">for</span> <span class="name">dtype</span> <span class="operator word">in</span> <span class="punctuation">[</span><span class="name">np</span><span class="operator">.</span><span class="name">int8</span><span class="punctuation">,</span> <span class="name">np</span><span class="operator">.</span><span class="name">int32</span><span class="punctuation">,</span> <span class="name">np</span><span class="operator">.</span><span class="name">int64</span><span class="punctuation">]:</span>
<span class="keyword">print</span> <span class="name">np</span><span class="operator">.</span><span class="name">iinfo</span><span class="punctuation">(</span><span class="name">dtype</span><span class="punctuation">)</span><span class="operator">.</span><span class="name">min</span>
<span class="keyword">print</span> <span class="name">np</span><span class="operator">.</span><span class="name">iinfo</span><span class="punctuation">(</span><span class="name">dtype</span><span class="punctuation">)</span><span class="operator">.</span><span class="name">max</span>
<span class="keyword">for</span> <span class="name">dtype</span> <span class="operator word">in</span> <span class="punctuation">[</span><span class="name">np</span><span class="operator">.</span><span class="name">float32</span><span class="punctuation">,</span> <span class="name">np</span><span class="operator">.</span><span class="name">float64</span><span class="punctuation">]:</span>
<span class="keyword">print</span> <span class="name">np</span><span class="operator">.</span><span class="name">finfo</span><span class="punctuation">(</span><span class="name">dtype</span><span class="punctuation">)</span><span class="operator">.</span><span class="name">min</span>
<span class="keyword">print</span> <span class="name">np</span><span class="operator">.</span><span class="name">finfo</span><span class="punctuation">(</span><span class="name">dtype</span><span class="punctuation">)</span><span class="operator">.</span><span class="name">max</span>
<span class="keyword">print</span> <span class="name">np</span><span class="operator">.</span><span class="name">finfo</span><span class="punctuation">(</span><span class="name">dtype</span><span class="punctuation">)</span><span class="operator">.</span><span class="name">eps</span>
</pre>
</li>
<li><p class="first">Create a structured array representing a position (x,y) and a color (r,g,b)</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">zeros</span><span class="punctuation">(</span><span class="literal number integer">10</span><span class="punctuation">,</span> <span class="punctuation">[</span> <span class="punctuation">(</span><span class="literal string">'position'</span><span class="punctuation">,</span> <span class="punctuation">[</span> <span class="punctuation">(</span><span class="literal string">'x'</span><span class="punctuation">,</span> <span class="name builtin">float</span><span class="punctuation">,</span> <span class="literal number integer">1</span><span class="punctuation">),</span>
<span class="punctuation">(</span><span class="literal string">'y'</span><span class="punctuation">,</span> <span class="name builtin">float</span><span class="punctuation">,</span> <span class="literal number integer">1</span><span class="punctuation">)]),</span>
<span class="punctuation">(</span><span class="literal string">'color'</span><span class="punctuation">,</span> <span class="punctuation">[</span> <span class="punctuation">(</span><span class="literal string">'r'</span><span class="punctuation">,</span> <span class="name builtin">float</span><span class="punctuation">,</span> <span class="literal number integer">1</span><span class="punctuation">),</span>
<span class="punctuation">(</span><span class="literal string">'g'</span><span class="punctuation">,</span> <span class="name builtin">float</span><span class="punctuation">,</span> <span class="literal number integer">1</span><span class="punctuation">),</span>
<span class="punctuation">(</span><span class="literal string">'b'</span><span class="punctuation">,</span> <span class="name builtin">float</span><span class="punctuation">,</span> <span class="literal number integer">1</span><span class="punctuation">)])])</span>
</pre>
</li>
<li><p class="first">Consider a random vector with shape (100,2) representing coordinates, find
point by point distances</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">random</span><span class="operator">.</span><span class="name">random</span><span class="punctuation">((</span><span class="literal number integer">10</span><span class="punctuation">,</span><span class="literal number integer">2</span><span class="punctuation">))</span>
<span class="name">X</span><span class="punctuation">,</span><span class="name">Y</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">atleast_2d</span><span class="punctuation">(</span><span class="name">Z</span><span class="punctuation">[:,</span><span class="literal number integer">0</span><span class="punctuation">]),</span> <span class="name">np</span><span class="operator">.</span><span class="name">atleast_2d</span><span class="punctuation">(</span><span class="name">Z</span><span class="punctuation">[:,</span><span class="literal number integer">1</span><span class="punctuation">])</span>
<span class="name">D</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">sqrt</span><span class="punctuation">(</span> <span class="punctuation">(</span><span class="name">X</span><span class="operator">-</span><span class="name">X</span><span class="operator">.</span><span class="name">T</span><span class="punctuation">)</span><span class="operator">**</span><span class="literal number integer">2</span> <span class="operator">+</span> <span class="punctuation">(</span><span class="name">Y</span><span class="operator">-</span><span class="name">Y</span><span class="operator">.</span><span class="name">T</span><span class="punctuation">)</span><span class="operator">**</span><span class="literal number integer">2</span><span class="punctuation">)</span>
<span class="comment"># Much faster with scipy</span>
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">random</span><span class="operator">.</span><span class="name">random</span><span class="punctuation">((</span><span class="literal number integer">10</span><span class="punctuation">,</span><span class="literal number integer">2</span><span class="punctuation">))</span>
<span class="name">D</span> <span class="operator">=</span> <span class="name">scipy</span><span class="operator">.</span><span class="name">spatial</span><span class="operator">.</span><span class="name">distance</span><span class="operator">.</span><span class="name">cdist</span><span class="punctuation">(</span><span class="name">Z</span><span class="punctuation">,</span><span class="name">Z</span><span class="punctuation">)</span>
</pre>
</li>
<li><p class="first">Generate a generic 2D Gaussian-like array</p>
<pre class="code python literal-block">
<span class="name">X</span><span class="punctuation">,</span> <span class="name">Y</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">meshgrid</span><span class="punctuation">(</span><span class="name">np</span><span class="operator">.</span><span class="name">linspace</span><span class="punctuation">(</span><span class="operator">-</span><span class="literal number integer">1</span><span class="punctuation">,</span><span class="literal number integer">1</span><span class="punctuation">,</span><span class="literal number integer">100</span><span class="punctuation">),</span> <span class="name">np</span><span class="operator">.</span><span class="name">linspace</span><span class="punctuation">(</span><span class="operator">-</span><span class="literal number integer">1</span><span class="punctuation">,</span><span class="literal number integer">1</span><span class="punctuation">,</span><span class="literal number integer">100</span><span class="punctuation">))</span>
<span class="name">D</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">sqrt</span><span class="punctuation">(</span><span class="name">X</span><span class="operator">*</span><span class="name">X</span><span class="operator">+</span><span class="name">Y</span><span class="operator">*</span><span class="name">Y</span><span class="punctuation">)</span>
<span class="name">sigma</span><span class="punctuation">,</span> <span class="name">mu</span> <span class="operator">=</span> <span class="literal number float">1.0</span><span class="punctuation">,</span> <span class="literal number float">0.0</span>
<span class="name">G</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">exp</span><span class="punctuation">(</span><span class="operator">-</span><span class="punctuation">(</span> <span class="punctuation">(</span><span class="name">D</span><span class="operator">-</span><span class="name">mu</span><span class="punctuation">)</span><span class="operator">**</span><span class="literal number integer">2</span> <span class="operator">/</span> <span class="punctuation">(</span> <span class="literal number float">2.0</span> <span class="operator">*</span> <span class="name">sigma</span><span class="operator">**</span><span class="literal number integer">2</span> <span class="punctuation">)</span> <span class="punctuation">)</span> <span class="punctuation">)</span>
</pre>
</li>
<li><p class="first">Consider the vector [1, 2, 3, 4, 5], how to build a new vector with 3
consecutive zeros interleaved between each value ?</p>
<pre class="code python literal-block">
<span class="comment"># Author: Warren Weckesser</span>
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">array</span><span class="punctuation">([</span><span class="literal number integer">1</span><span class="punctuation">,</span><span class="literal number integer">2</span><span class="punctuation">,</span><span class="literal number integer">3</span><span class="punctuation">,</span><span class="literal number integer">4</span><span class="punctuation">,</span><span class="literal number integer">5</span><span class="punctuation">])</span>
<span class="name">nz</span> <span class="operator">=</span> <span class="literal number integer">3</span>
<span class="name">Z0</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">zeros</span><span class="punctuation">(</span><span class="name builtin">len</span><span class="punctuation">(</span><span class="name">Z</span><span class="punctuation">)</span> <span class="operator">+</span> <span class="punctuation">(</span><span class="name builtin">len</span><span class="punctuation">(</span><span class="name">Z</span><span class="punctuation">)</span><span class="operator">-</span><span class="literal number integer">1</span><span class="punctuation">)</span><span class="operator">*</span><span class="punctuation">(</span><span class="name">nz</span><span class="punctuation">))</span>
<span class="name">Z0</span><span class="punctuation">[::</span><span class="name">nz</span><span class="operator">+</span><span class="literal number integer">1</span><span class="punctuation">]</span> <span class="operator">=</span> <span class="name">Z</span>
</pre>
</li>
<li><p class="first">Find the nearest value from a given value in an array</p>
<pre class="code python literal-block">
<span class="name">Z</span><span class="operator">.</span><span class="name">flat</span><span class="punctuation">[</span><span class="name">np</span><span class="operator">.</span><span class="name">abs</span><span class="punctuation">(</span><span class="name">Z</span> <span class="operator">-</span> <span class="name">z</span><span class="punctuation">)</span><span class="operator">.</span><span class="name">argmin</span><span class="punctuation">()]</span>
</pre>
</li>
</ol>
</div>
<div class="section" id="journeyman">
<h1><a class="toc-backref" href="#id4">Journeyman</a></h1>
<ol class="arabic">
<li><p class="first">Consider the following file:</p>
<pre class="literal-block">
1,2,3,4,5
6,,,7,8
,,9,10,11
</pre>
<p>How to read it ?</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">genfromtxt</span><span class="punctuation">(</span><span class="literal string">&quot;missing.dat&quot;</span><span class="punctuation">,</span> <span class="name">delimiter</span><span class="operator">=</span><span class="literal string">&quot;,&quot;</span><span class="punctuation">)</span>
</pre>
</li>
<li><p class="first">Consider a generator function that generates 10 integers and use it to build an
array</p>
<pre class="code python literal-block">
<span class="keyword">def</span> <span class="name function">generate</span><span class="punctuation">():</span>
<span class="keyword">for</span> <span class="name">x</span> <span class="operator word">in</span> <span class="name builtin">xrange</span><span class="punctuation">(</span><span class="literal number integer">10</span><span class="punctuation">):</span>
<span class="keyword">yield</span> <span class="name">x</span>
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">fromiter</span><span class="punctuation">(</span><span class="name">generate</span><span class="punctuation">(),</span><span class="name">dtype</span><span class="operator">=</span><span class="name builtin">float</span><span class="punctuation">,</span><span class="name">count</span><span class="operator">=-</span><span class="literal number integer">1</span><span class="punctuation">)</span>
</pre>
</li>
<li><p class="first">Consider a given vector, how to add 1 to each element indexed by a second
vector (be careful with repeated indices) ?</p>
<pre class="code python literal-block">
<span class="comment"># Author: Brett Olsen</span>
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">ones</span><span class="punctuation">(</span><span class="literal number integer">10</span><span class="punctuation">)</span>
<span class="name">I</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">random</span><span class="operator">.</span><span class="name">randint</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span><span class="name builtin">len</span><span class="punctuation">(</span><span class="name">Z</span><span class="punctuation">),</span><span class="literal number integer">20</span><span class="punctuation">)</span>
<span class="name">Z</span> <span class="operator">+=</span> <span class="name">np</span><span class="operator">.</span><span class="name">bincount</span><span class="punctuation">(</span><span class="name">I</span><span class="punctuation">,</span> <span class="name">minlength</span><span class="operator">=</span><span class="name builtin">len</span><span class="punctuation">(</span><span class="name">Z</span><span class="punctuation">))</span>
</pre>
</li>
<li><p class="first">How to accumulate elements of a vector (X) to an array (F) based on an index
list (I) ?</p>
<pre class="code python literal-block">
<span class="comment"># Author: Alan G Isaac</span>
<span class="name">X</span> <span class="operator">=</span> <span class="punctuation">[</span><span class="literal number integer">1</span><span class="punctuation">,</span><span class="literal number integer">2</span><span class="punctuation">,</span><span class="literal number integer">3</span><span class="punctuation">,</span><span class="literal number integer">4</span><span class="punctuation">,</span><span class="literal number integer">5</span><span class="punctuation">,</span><span class="literal number integer">6</span><span class="punctuation">]</span>
<span class="name">I</span> <span class="operator">=</span> <span class="punctuation">[</span><span class="literal number integer">1</span><span class="punctuation">,</span><span class="literal number integer">3</span><span class="punctuation">,</span><span class="literal number integer">9</span><span class="punctuation">,</span><span class="literal number integer">3</span><span class="punctuation">,</span><span class="literal number integer">4</span><span class="punctuation">,</span><span class="literal number integer">1</span><span class="punctuation">]</span>
<span class="name">F</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">bincount</span><span class="punctuation">(</span><span class="name">I</span><span class="punctuation">,</span><span class="name">X</span><span class="punctuation">)</span>
</pre>
</li>
<li><p class="first">Considering a (w,h,3) image of (dtype=ubyte), compute the number of unique
colors</p>
<pre class="code python literal-block">
<span class="comment"># Author: Nadav Horesh</span>
<span class="name">w</span><span class="punctuation">,</span><span class="name">h</span> <span class="operator">=</span> <span class="literal number integer">16</span><span class="punctuation">,</span><span class="literal number integer">16</span>
<span class="name">I</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">random</span><span class="operator">.</span><span class="name">randint</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span><span class="literal number integer">2</span><span class="punctuation">,(</span><span class="name">h</span><span class="punctuation">,</span><span class="name">w</span><span class="punctuation">,</span><span class="literal number integer">3</span><span class="punctuation">))</span><span class="operator">.</span><span class="name">astype</span><span class="punctuation">(</span><span class="name">np</span><span class="operator">.</span><span class="name">ubyte</span><span class="punctuation">)</span>
<span class="name">F</span> <span class="operator">=</span> <span class="name">I</span><span class="punctuation">[</span><span class="operator">...</span><span class="punctuation">,</span><span class="literal number integer">0</span><span class="punctuation">]</span><span class="operator">*</span><span class="literal number integer">256</span><span class="operator">*</span><span class="literal number integer">256</span> <span class="operator">+</span> <span class="name">I</span><span class="punctuation">[</span><span class="operator">...</span><span class="punctuation">,</span><span class="literal number integer">1</span><span class="punctuation">]</span><span class="operator">*</span><span class="literal number integer">256</span> <span class="operator">+</span><span class="name">I</span><span class="punctuation">[</span><span class="operator">...</span><span class="punctuation">,</span><span class="literal number integer">2</span><span class="punctuation">]</span>
<span class="name">n</span> <span class="operator">=</span> <span class="name builtin">len</span><span class="punctuation">(</span><span class="name">np</span><span class="operator">.</span><span class="name">unique</span><span class="punctuation">(</span><span class="name">F</span><span class="punctuation">))</span>
</pre>
</li>
<li><p class="first">Considering a four dimensions array, how to get sum over the last two axis at once ?</p>
<pre class="code python literal-block">
<span class="name">A</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">random</span><span class="operator">.</span><span class="name">randint</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span><span class="literal number integer">10</span><span class="punctuation">,(</span><span class="literal number integer">3</span><span class="punctuation">,</span><span class="literal number integer">4</span><span class="punctuation">,</span><span class="literal number integer">3</span><span class="punctuation">,</span><span class="literal number integer">4</span><span class="punctuation">))</span>
<span class="name builtin">sum</span> <span class="operator">=</span> <span class="name">A</span><span class="operator">.</span><span class="name">reshape</span><span class="punctuation">(</span><span class="name">A</span><span class="operator">.</span><span class="name">shape</span><span class="punctuation">[:</span><span class="operator">-</span><span class="literal number integer">2</span><span class="punctuation">]</span> <span class="operator">+</span> <span class="punctuation">(</span><span class="operator">-</span><span class="literal number integer">1</span><span class="punctuation">,))</span><span class="operator">.</span><span class="name">sum</span><span class="punctuation">(</span><span class="name">axis</span><span class="operator">=-</span><span class="literal number integer">1</span><span class="punctuation">)</span>
</pre>
</li>
</ol>
</div>
<div class="section" id="craftsman">
<h1><a class="toc-backref" href="#id5">Craftsman</a></h1>
<ol class="arabic">
<li><p class="first">Consider a one-dimensional array Z, build a two-dimensional array whose
first row is (Z[0],Z[1],Z[2]) and each subsequent row is shifted by 1 (last
row should be (Z[-3],Z[-2],Z[-1])</p>
<pre class="code python literal-block">
<span class="comment"># Author: Joe Kington / Erik Rigtorp</span>
<span class="keyword">def</span> <span class="name function">rolling</span><span class="punctuation">(</span><span class="name">a</span><span class="punctuation">,</span> <span class="name">window</span><span class="punctuation">):</span>
<span class="name">shape</span> <span class="operator">=</span> <span class="punctuation">(</span><span class="name">a</span><span class="operator">.</span><span class="name">size</span> <span class="operator">-</span> <span class="name">window</span> <span class="operator">+</span> <span class="literal number integer">1</span><span class="punctuation">,</span> <span class="name">window</span><span class="punctuation">)</span>
<span class="name">strides</span> <span class="operator">=</span> <span class="punctuation">(</span><span class="name">a</span><span class="operator">.</span><span class="name">itemsize</span><span class="punctuation">,</span> <span class="name">a</span><span class="operator">.</span><span class="name">itemsize</span><span class="punctuation">)</span>
<span class="keyword">return</span> <span class="name">np</span><span class="operator">.</span><span class="name">lib</span><span class="operator">.</span><span class="name">stride_tricks</span><span class="operator">.</span><span class="name">as_strided</span><span class="punctuation">(</span><span class="name">a</span><span class="punctuation">,</span> <span class="name">shape</span><span class="operator">=</span><span class="name">shape</span><span class="punctuation">,</span> <span class="name">strides</span><span class="operator">=</span><span class="name">strides</span><span class="punctuation">)</span>
<span class="name">Z</span> <span class="operator">=</span> <span class="name">rolling</span><span class="punctuation">(</span><span class="name">np</span><span class="operator">.</span><span class="name">arange</span><span class="punctuation">(</span><span class="literal number integer">100</span><span class="punctuation">),</span> <span class="literal number integer">3</span><span class="punctuation">)</span>
</pre>
</li>
<li><p class="first">Consider a set of 100 triplets describing 100 triangles (with shared
vertices), find the set of unique line segments composing all the triangles.</p>
<pre class="code python literal-block">
<span class="comment"># Author: Nicolas Rougier</span>
<span class="name">faces</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">random</span><span class="operator">.</span><span class="name">randint</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span><span class="literal number integer">100</span><span class="punctuation">,(</span><span class="literal number integer">100</span><span class="punctuation">,</span><span class="literal number integer">3</span><span class="punctuation">))</span>
<span class="name">F</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">roll</span><span class="punctuation">(</span><span class="name">faces</span><span class="operator">.</span><span class="name">repeat</span><span class="punctuation">(</span><span class="literal number integer">2</span><span class="punctuation">,</span><span class="name">axis</span><span class="operator">=</span><span class="literal number integer">1</span><span class="punctuation">),</span><span class="operator">-</span><span class="literal number integer">1</span><span class="punctuation">,</span><span class="name">axis</span><span class="operator">=</span><span class="literal number integer">1</span><span class="punctuation">)</span>
<span class="name">F</span> <span class="operator">=</span> <span class="name">F</span><span class="operator">.</span><span class="name">reshape</span><span class="punctuation">(</span><span class="name builtin">len</span><span class="punctuation">(</span><span class="name">F</span><span class="punctuation">)</span><span class="operator">*</span><span class="literal number integer">3</span><span class="punctuation">,</span><span class="literal number integer">2</span><span class="punctuation">)</span>
<span class="name">F</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">sort</span><span class="punctuation">(</span><span class="name">F</span><span class="punctuation">,</span><span class="name">axis</span><span class="operator">=</span><span class="literal number integer">1</span><span class="punctuation">)</span>
<span class="name">G</span> <span class="operator">=</span> <span class="name">F</span><span class="operator">.</span><span class="name">view</span><span class="punctuation">(</span> <span class="name">dtype</span><span class="operator">=</span><span class="punctuation">[(</span><span class="literal string">'p0'</span><span class="punctuation">,</span><span class="name">F</span><span class="operator">.</span><span class="name">dtype</span><span class="punctuation">),(</span><span class="literal string">'p1'</span><span class="punctuation">,</span><span class="name">F</span><span class="operator">.</span><span class="name">dtype</span><span class="punctuation">)]</span> <span class="punctuation">)</span>
<span class="name">G</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">unique</span><span class="punctuation">(</span><span class="name">G</span><span class="punctuation">)</span>
</pre>
</li>
</ol>
</div>
<div class="section" id="artisan">
<h1><a class="toc-backref" href="#id6">Artisan</a></h1>
<ol class="arabic">
<li><p class="first">Considering a 100x3 matrix, extract rows with unequal values (e.g. [2,2,3])</p>
<pre class="code python literal-block">
<span class="comment"># Author: Robert Kern</span>
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">random</span><span class="operator">.</span><span class="name">randint</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span><span class="literal number integer">5</span><span class="punctuation">,(</span><span class="literal number integer">100</span><span class="punctuation">,</span><span class="literal number integer">3</span><span class="punctuation">))</span>
<span class="name">E</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">logical_and</span><span class="operator">.</span><span class="name">reduce</span><span class="punctuation">(</span><span class="name">Z</span><span class="punctuation">[:,</span><span class="literal number integer">1</span><span class="punctuation">:]</span> <span class="operator">==</span> <span class="name">Z</span><span class="punctuation">[:,:</span><span class="operator">-</span><span class="literal number integer">1</span><span class="punctuation">],</span> <span class="name">axis</span><span class="operator">=</span><span class="literal number integer">1</span><span class="punctuation">)</span>
<span class="name">U</span> <span class="operator">=</span> <span class="name">Z</span><span class="punctuation">[</span><span class="operator">~</span><span class="name">E</span><span class="punctuation">]</span>
</pre>
</li>
<li><p class="first">Convert a vector of ints into a matrix binary representation.</p>
<pre class="code python literal-block">
<span class="comment"># Author: Warren Weckesser</span>
<span class="name">I</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">array</span><span class="punctuation">([</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">1</span><span class="punctuation">,</span> <span class="literal number integer">2</span><span class="punctuation">,</span> <span class="literal number integer">3</span><span class="punctuation">,</span> <span class="literal number integer">15</span><span class="punctuation">,</span> <span class="literal number integer">16</span><span class="punctuation">,</span> <span class="literal number integer">32</span><span class="punctuation">,</span> <span class="literal number integer">64</span><span class="punctuation">,</span> <span class="literal number integer">128</span><span class="punctuation">])</span>
<span class="name">B</span> <span class="operator">=</span> <span class="punctuation">((</span><span class="name">I</span><span class="operator">.</span><span class="name">reshape</span><span class="punctuation">(</span><span class="operator">-</span><span class="literal number integer">1</span><span class="punctuation">,</span><span class="literal number integer">1</span><span class="punctuation">)</span> <span class="operator">&amp;</span> <span class="punctuation">(</span><span class="literal number integer">2</span><span class="operator">**</span><span class="name">np</span><span class="operator">.</span><span class="name">arange</span><span class="punctuation">(</span><span class="literal number integer">8</span><span class="punctuation">)))</span> <span class="operator">!=</span> <span class="literal number integer">0</span><span class="punctuation">)</span><span class="operator">.</span><span class="name">astype</span><span class="punctuation">(</span><span class="name builtin">int</span><span class="punctuation">)</span>
<span class="name">B</span> <span class="operator">=</span> <span class="name">B</span><span class="punctuation">[:,::</span><span class="operator">-</span><span class="literal number integer">1</span><span class="punctuation">]</span>
<span class="comment"># Author: Daniel T. McDonald</span>
<span class="name">I</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">array</span><span class="punctuation">([</span><span class="literal number integer">0</span><span class="punctuation">,</span> <span class="literal number integer">1</span><span class="punctuation">,</span> <span class="literal number integer">2</span><span class="punctuation">,</span> <span class="literal number integer">3</span><span class="punctuation">,</span> <span class="literal number integer">15</span><span class="punctuation">,</span> <span class="literal number integer">16</span><span class="punctuation">,</span> <span class="literal number integer">32</span><span class="punctuation">,</span> <span class="literal number integer">64</span><span class="punctuation">,</span> <span class="literal number integer">128</span><span class="punctuation">],</span> <span class="name">dtype</span><span class="operator">=</span><span class="name">np</span><span class="operator">.</span><span class="name">uint8</span><span class="punctuation">)</span>
<span class="name">np</span><span class="operator">.</span><span class="name">unpackbits</span><span class="punctuation">(</span><span class="name">I</span><span class="punctuation">[:,</span> <span class="name">np</span><span class="operator">.</span><span class="name">newaxis</span><span class="punctuation">],</span> <span class="name">axis</span><span class="operator">=</span><span class="literal number integer">1</span><span class="punctuation">)</span>
</pre>
</li>
</ol>
</div>
<div class="section" id="adept">
<h1><a class="toc-backref" href="#id7">Adept</a></h1>
<ol class="arabic">
<li><p class="first">Consider an arbitrary array, write a function that extract a subpart with a
fixed shape and centered on a given element (pad with a <tt class="docutils literal">fill</tt> value when
necessary)</p>
<pre class="code python literal-block">
<span class="comment"># Author: Nicolas Rougier</span>
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">random</span><span class="operator">.</span><span class="name">random</span><span class="punctuation">((</span><span class="literal number integer">25</span><span class="punctuation">,</span><span class="literal number integer">25</span><span class="punctuation">))</span>
<span class="name">shape</span> <span class="operator">=</span> <span class="punctuation">(</span><span class="literal number integer">3</span><span class="punctuation">,</span><span class="literal number integer">3</span><span class="punctuation">)</span>
<span class="name">fill</span> <span class="operator">=</span> <span class="literal number integer">0</span>
<span class="name">position</span> <span class="operator">=</span> <span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span><span class="literal number integer">0</span><span class="punctuation">)</span>
<span class="name">R</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">ones</span><span class="punctuation">(</span><span class="name">shape</span><span class="punctuation">,</span> <span class="name">dtype</span><span class="operator">=</span><span class="name">Z</span><span class="operator">.</span><span class="name">dtype</span><span class="punctuation">)</span><span class="operator">*</span><span class="name">fill</span>
<span class="name">P</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">array</span><span class="punctuation">(</span><span class="name builtin">list</span><span class="punctuation">(</span><span class="name">position</span><span class="punctuation">))</span><span class="operator">.</span><span class="name">astype</span><span class="punctuation">(</span><span class="name builtin">int</span><span class="punctuation">)</span>
<span class="name">Rs</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">array</span><span class="punctuation">(</span><span class="name builtin">list</span><span class="punctuation">(</span><span class="name">R</span><span class="operator">.</span><span class="name">shape</span><span class="punctuation">))</span><span class="operator">.</span><span class="name">astype</span><span class="punctuation">(</span><span class="name builtin">int</span><span class="punctuation">)</span>
<span class="name">Zs</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">array</span><span class="punctuation">(</span><span class="name builtin">list</span><span class="punctuation">(</span><span class="name">Z</span><span class="operator">.</span><span class="name">shape</span><span class="punctuation">))</span><span class="operator">.</span><span class="name">astype</span><span class="punctuation">(</span><span class="name builtin">int</span><span class="punctuation">)</span>
<span class="name">R_start</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">zeros</span><span class="punctuation">((</span><span class="name builtin">len</span><span class="punctuation">(</span><span class="name">shape</span><span class="punctuation">),))</span><span class="operator">.</span><span class="name">astype</span><span class="punctuation">(</span><span class="name builtin">int</span><span class="punctuation">)</span>
<span class="name">R_stop</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">array</span><span class="punctuation">(</span><span class="name builtin">list</span><span class="punctuation">(</span><span class="name">shape</span><span class="punctuation">))</span><span class="operator">.</span><span class="name">astype</span><span class="punctuation">(</span><span class="name builtin">int</span><span class="punctuation">)</span>
<span class="name">Z_start</span> <span class="operator">=</span> <span class="punctuation">(</span><span class="name">P</span><span class="operator">-</span><span class="name">Rs</span><span class="operator">//</span><span class="literal number integer">2</span><span class="punctuation">)</span>
<span class="name">Z_stop</span> <span class="operator">=</span> <span class="punctuation">(</span><span class="name">P</span><span class="operator">+</span><span class="name">Rs</span><span class="operator">//</span><span class="literal number integer">2</span><span class="punctuation">)</span><span class="operator">+</span><span class="name">Rs</span><span class="operator">%</span><span class="literal number integer">2</span>
<span class="name">R_start</span> <span class="operator">=</span> <span class="punctuation">(</span><span class="name">R_start</span> <span class="operator">-</span> <span class="name">np</span><span class="operator">.</span><span class="name">minimum</span><span class="punctuation">(</span><span class="name">Z_start</span><span class="punctuation">,</span><span class="literal number integer">0</span><span class="punctuation">))</span><span class="operator">.</span><span class="name">tolist</span><span class="punctuation">()</span>
<span class="name">Z_start</span> <span class="operator">=</span> <span class="punctuation">(</span><span class="name">np</span><span class="operator">.</span><span class="name">maximum</span><span class="punctuation">(</span><span class="name">Z_start</span><span class="punctuation">,</span><span class="literal number integer">0</span><span class="punctuation">))</span><span class="operator">.</span><span class="name">tolist</span><span class="punctuation">()</span>
<span class="name">R_stop</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">maximum</span><span class="punctuation">(</span><span class="name">R_start</span><span class="punctuation">,</span> <span class="punctuation">(</span><span class="name">R_stop</span> <span class="operator">-</span> <span class="name">np</span><span class="operator">.</span><span class="name">maximum</span><span class="punctuation">(</span><span class="name">Z_stop</span><span class="operator">-</span><span class="name">Zs</span><span class="punctuation">,</span><span class="literal number integer">0</span><span class="punctuation">)))</span><span class="operator">.</span><span class="name">tolist</span><span class="punctuation">()</span>
<span class="name">Z_stop</span> <span class="operator">=</span> <span class="punctuation">(</span><span class="name">np</span><span class="operator">.</span><span class="name">minimum</span><span class="punctuation">(</span><span class="name">Z_stop</span><span class="punctuation">,</span><span class="name">Zs</span><span class="punctuation">))</span><span class="operator">.</span><span class="name">tolist</span><span class="punctuation">()</span>
<span class="name">r</span> <span class="operator">=</span> <span class="punctuation">[</span><span class="name builtin">slice</span><span class="punctuation">(</span><span class="name">start</span><span class="punctuation">,</span><span class="name">stop</span><span class="punctuation">)</span> <span class="keyword">for</span> <span class="name">start</span><span class="punctuation">,</span><span class="name">stop</span> <span class="operator word">in</span> <span class="name builtin">zip</span><span class="punctuation">(</span><span class="name">R_start</span><span class="punctuation">,</span><span class="name">R_stop</span><span class="punctuation">)]</span>
<span class="name">z</span> <span class="operator">=</span> <span class="punctuation">[</span><span class="name builtin">slice</span><span class="punctuation">(</span><span class="name">start</span><span class="punctuation">,</span><span class="name">stop</span><span class="punctuation">)</span> <span class="keyword">for</span> <span class="name">start</span><span class="punctuation">,</span><span class="name">stop</span> <span class="operator word">in</span> <span class="name builtin">zip</span><span class="punctuation">(</span><span class="name">Z_start</span><span class="punctuation">,</span><span class="name">Z_stop</span><span class="punctuation">)]</span>
<span class="name">R</span><span class="punctuation">[</span><span class="name">r</span><span class="punctuation">]</span> <span class="operator">=</span> <span class="name">Z</span><span class="punctuation">[</span><span class="name">z</span><span class="punctuation">]</span>
</pre>
</li>
</ol>
</div>
<div class="section" id="expert">
<h1><a class="toc-backref" href="#id8">Expert</a></h1>
<ol class="arabic">
<li><p class="first">Consider two arrays A and B of shape (8,3) and (2,2). How to find rows of A
that contain elements of each row of B regardless of the order of the elements
in B ?</p>
<pre class="code python literal-block">
<span class="comment"># Author: Gabe Schwartz</span>
<span class="name">A</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">random</span><span class="operator">.</span><span class="name">randint</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span><span class="literal number integer">5</span><span class="punctuation">,(</span><span class="literal number integer">8</span><span class="punctuation">,</span><span class="literal number integer">3</span><span class="punctuation">))</span>
<span class="name">B</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">random</span><span class="operator">.</span><span class="name">randint</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span><span class="literal number integer">5</span><span class="punctuation">,(</span><span class="literal number integer">2</span><span class="punctuation">,</span><span class="literal number integer">2</span><span class="punctuation">))</span>
<span class="name">C</span> <span class="operator">=</span> <span class="punctuation">(</span><span class="name">A</span><span class="punctuation">[</span><span class="operator">...</span><span class="punctuation">,</span> <span class="name">np</span><span class="operator">.</span><span class="name">newaxis</span><span class="punctuation">,</span> <span class="name">np</span><span class="operator">.</span><span class="name">newaxis</span><span class="punctuation">]</span> <span class="operator">==</span> <span class="name">B</span><span class="punctuation">)</span>
<span class="name">rows</span> <span class="operator">=</span> <span class="punctuation">(</span><span class="name">C</span><span class="operator">.</span><span class="name">sum</span><span class="punctuation">(</span><span class="name">axis</span><span class="operator">=</span><span class="punctuation">(</span><span class="literal number integer">1</span><span class="punctuation">,</span><span class="literal number integer">2</span><span class="punctuation">,</span><span class="literal number integer">3</span><span class="punctuation">))</span> <span class="operator">&gt;=</span> <span class="name">B</span><span class="operator">.</span><span class="name">shape</span><span class="punctuation">[</span><span class="literal number integer">1</span><span class="punctuation">])</span><span class="operator">.</span><span class="name">nonzero</span><span class="punctuation">()[</span><span class="literal number integer">0</span><span class="punctuation">]</span>
</pre>
</li>
<li><p class="first">Extract all the contiguous 3x3 blocks from a random 10x10 matrix.</p>
<pre class="code python literal-block">
<span class="name">Z</span> <span class="operator">=</span> <span class="name">np</span><span class="operator">.</span><span class="name">random</span><span class="operator">.</span><span class="name">randint</span><span class="punctuation">(</span><span class="literal number integer">0</span><span class="punctuation">,</span><span class="literal number integer">5</span><span class="punctuation">,(</span><span class="literal number integer">10</span><span class="punctuation">,</span><span class="literal number integer">10</span><span class="punctuation">))</span>
<span class="name">n</span> <span class="operator">=</span> <span class="literal number integer">3</span>
<span class="name">i</span> <span class="operator">=</span> <span class="literal number integer">1</span> <span class="operator">+</span> <span class="punctuation">(</span><span class="name">Z</span><span class="operator">.</span><span class="name">shape</span><span class="punctuation">[</span><span class="literal number integer">0</span><span class="punctuation">]</span><span class="operator">-</span><span class="literal number integer">3</span><span class="punctuation">)</span>
<span class="name">j</span> <span class="operator">=</span> <span class="literal number integer">1</span> <span class="operator">+</span> <span class="punctuation">(</span><span class="name">Z</span><span class="operator">.</span><span class="name">shape</span><span class="punctuation">[</span><span class="literal number integer">1</span><span class="punctuation">]</span><span class="operator">-</span><span class="literal number integer">3</span><span class="punctuation">)</span>
<span class="name">C</span> <span class="operator">=</span> <span class="name">stride_tricks</span><span class="operator">.</span><span class="name">as_strided</span><span class="punctuation">(</span><span class="name">Z</span><span class="punctuation">,</span> <span class="name">shape</span><span class="operator">=</span><span class="punctuation">(</span><span class="name">i</span><span class="punctuation">,</span> <span class="name">j</span><span class="punctuation">,</span> <span class="name">n</span><span class="punctuation">,</span> <span class="name">n</span><span class="punctuation">),</span> <span class="name">strides</span><span class="operator">=</span><span class="name">Z</span><span class="operator">.</span><span class="name">strides</span> <span class="operator">+</span> <span class="name">Z</span><span class="operator">.</span><span class="name">strides</span><span class="punctuation">)</span>
</pre>
</li>
</ol>
</div>
<div class="section" id="master">
<h1><a class="toc-backref" href="#id9">Master</a></h1>
</div>
<div class="section" id="archmaster">
<h1><a class="toc-backref" href="#id10">Archmaster</a></h1>
</div>
</div>
</body>
</html>

481
index.rst Normal file
View File

@@ -0,0 +1,481 @@
===================
100 numpy exercises
===================
-------------------------------------
A joint effort of the numpy community
-------------------------------------
.. contents::
:local:
:depth: 1
Neophyte
========
1. Import the numpy package under the name ``np``
.. code:: python
import numpy as np
#. Print the numpy version and the configuration.
.. code:: python
print np.__version__
np.__config__.show()
#. Create a null vector of size 10
.. code:: python
Z = np.zeros(10)
#. Create a null vector of size 10 but the fifth value which is 1
.. code:: python
Z = np.zeros(10)
Z[4] = 1
#. Create a vector with values ranging from 10 to 99
.. code:: python
Z = np.arange(10,100)
#. Create a 3x3 matrix with values ranging from 0 to 8
.. code:: python
Z = np.arange(9).reshape(3,3)
#. Find indices of non-zero elements from [1,2,0,0,4,0]
.. code:: python
nz = np.nonzero([1,2,0,0,4,0])
#. Declare a 3x3 identity matrix
.. code:: python
Z = np.eye(3)
#. Declare a 5x5 matrix with values 1,2,3,4 just below the diagonal
.. code:: python
Z = np.diag(1+np.arange(4),k=-1)
#. Declare a 10x10x10 array with random values
.. code:: python
Z = np.random.random((10,10,10))
Novice
======
#. Declare a 8x8 matrix and fill it with a checkerboard pattern
.. code:: python
Z = np.zeros((8,8))
Z[1::2,::2] = 1
Z[::2,1::2] = 1
#. Declare a 10x10 array with random values and find the minimum and maximum values
.. code:: python
Z = np.random.random((10,10))
Zmin, Zmax = Z.min(), Z.max()
#. Create a checkerboard 8x8 matrix using the tile function
.. code:: python
Z = np.tile( np.array([[0,1],[1,0]]), (4,4))
#. Normalize a 5x5 random matrix (between 0 and 1)
.. code:: python
Z = np.random.random((5,5))
Zmax,Zmin = Z.max(), Z.min()
Z = (Z - Zmin)/(Zmax - Zmin)
#. Multiply a 5x3 matrix by a 3x2 matrix (real matrix product)
.. code:: python
Z = np.dot(np.ones((5,3)), np.ones((3,2)))
#. Create a 10x10 matrix with row values ranging from 0 to 9
.. code:: python
Z = np.zeros((10,10))
Z += np.arange(10)
#. Create a vector of size 1000 with values ranging from 0 to 1, both excluded
.. code:: python
Z = np.random.linspace(0,1,1002,endpoint=True)[1:-1]
#. Create a random vector of size 100 and sort it
.. code:: python
Z = np.random.random(100)
Z.sort()
#. Consider two random matrices A anb B, check if they are equal.
.. code:: python
A = np.random.randint(0,2,(2,2))
B = np.random.randint(0,2,(2,2))
equal = np.allclose(A,B)
#. Create a random vector of size 1000 and find the mean value
.. code:: python
Z = np.random.random(1000)
m = Z.mean()
Apprentice
==========
#. Make an array immutable
.. code:: python
Z = np.zeros(10)
Z.flags.writeable = False
#. Consider a random 100x2 matrix representing cartesian coordinates, convert
them to polar coordinates
.. code:: python
Z = np.random.random((100,2))
X,Y = Z[:,0], Z[:,1]
R = np.sqrt(X**2+Y**2)
T = np.arctan2(Y,X)
#. Create random vector of size 100 and replace the maximum value by 0
.. code:: python
Z = np.random.random(100)
Z[Z.argmax()] = 0
#. Declare a structured array with ``x`` and ``y`` coordinates covering the
[0,1]x[0,1] area.
.. code:: python
Z = np.zeros((10,10), [('x',float),('y',float)])
Z['x'], Z['y'] = np.meshgrid(np.linspace(0,1,10),
np.linspace(0,1,10))
#. Print the minimum and maximum representable value for each numpy scalar type
.. code:: python
for dtype in [np.int8, np.int32, np.int64]:
print np.iinfo(dtype).min
print np.iinfo(dtype).max
for dtype in [np.float32, np.float64]:
print np.finfo(dtype).min
print np.finfo(dtype).max
print np.finfo(dtype).eps
#. Create a structured array representing a position (x,y) and a color (r,g,b)
.. code:: python
Z = np.zeros(10, [ ('position', [ ('x', float, 1),
('y', float, 1)]),
('color', [ ('r', float, 1),
('g', float, 1),
('b', float, 1)])])
#. Consider a random vector with shape (100,2) representing coordinates, find
point by point distances
.. code:: python
Z = np.random.random((10,2))
X,Y = np.atleast_2d(Z[:,0]), np.atleast_2d(Z[:,1])
D = np.sqrt( (X-X.T)**2 + (Y-Y.T)**2)
# Much faster with scipy
Z = np.random.random((10,2))
D = scipy.spatial.distance.cdist(Z,Z)
#. Generate a generic 2D Gaussian-like array
.. code:: python
X, Y = np.meshgrid(np.linspace(-1,1,100), np.linspace(-1,1,100))
D = np.sqrt(X*X+Y*Y)
sigma, mu = 1.0, 0.0
G = np.exp(-( (D-mu)**2 / ( 2.0 * sigma**2 ) ) )
#. Consider the vector [1, 2, 3, 4, 5], how to build a new vector with 3
consecutive zeros interleaved between each value ?
.. code:: python
# Author: Warren Weckesser
Z = np.array([1,2,3,4,5])
nz = 3
Z0 = np.zeros(len(Z) + (len(Z)-1)*(nz))
Z0[::nz+1] = Z
#. Find the nearest value from a given value in an array
.. code:: python
Z.flat[np.abs(Z - z).argmin()]
Journeyman
==========
#. Consider the following file::
1,2,3,4,5
6,,,7,8
,,9,10,11
How to read it ?
.. code:: python
Z = genfromtxt("missing.dat", delimiter=",")
#. Consider a generator function that generates 10 integers and use it to build an
array
.. code:: python
def generate():
for x in xrange(10):
yield x
Z = np.fromiter(generate(),dtype=float,count=-1)
#. Consider a given vector, how to add 1 to each element indexed by a second
vector (be careful with repeated indices) ?
.. code:: python
# Author: Brett Olsen
Z = np.ones(10)
I = np.random.randint(0,len(Z),20)
Z += np.bincount(I, minlength=len(Z))
#. How to accumulate elements of a vector (X) to an array (F) based on an index
list (I) ?
.. code:: python
# Author: Alan G Isaac
X = [1,2,3,4,5,6]
I = [1,3,9,3,4,1]
F = np.bincount(I,X)
#. Considering a (w,h,3) image of (dtype=ubyte), compute the number of unique
colors
.. code:: python
# Author: Nadav Horesh
w,h = 16,16
I = np.random.randint(0,2,(h,w,3)).astype(np.ubyte)
F = I[...,0]*256*256 + I[...,1]*256 +I[...,2]
n = len(np.unique(F))
np.unique(I)
#. Considering a four dimensions array, how to get sum over the last two axis at once ?
.. code:: python
A = np.random.randint(0,10,(3,4,3,4))
sum = A.reshape(A.shape[:-2] + (-1,)).sum(axis=-1)
Craftsman
=========
#. Consider a one-dimensional array Z, build a two-dimensional array whose
first row is (Z[0],Z[1],Z[2]) and each subsequent row is shifted by 1 (last
row should be (Z[-3],Z[-2],Z[-1])
.. code:: python
# Author: Joe Kington / Erik Rigtorp
def rolling(a, window):
shape = (a.size - window + 1, window)
strides = (a.itemsize, a.itemsize)
return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides)
Z = rolling(np.arange(100), 3)
#. Consider a set of 100 triplets describing 100 triangles (with shared
vertices), find the set of unique line segments composing all the triangles.
.. code:: python
# Author: Nicolas Rougier
faces = np.random.randint(0,100,(100,3))
F = np.roll(faces.repeat(2,axis=1),-1,axis=1)
F = F.reshape(len(F)*3,2)
F = np.sort(F,axis=1)
G = F.view( dtype=[('p0',F.dtype),('p1',F.dtype)] )
G = np.unique(G)
Artisan
=======
#. Considering a 100x3 matrix, extract rows with unequal values (e.g. [2,2,3])
.. code:: python
# Author: Robert Kern
Z = np.random.randint(0,5,(100,3))
E = np.logical_and.reduce(Z[:,1:] == Z[:,:-1], axis=1)
U = Z[~E]
#. Convert a vector of ints into a matrix binary representation.
.. code:: python
# Author: Warren Weckesser
I = np.array([0, 1, 2, 3, 15, 16, 32, 64, 128])
B = ((I.reshape(-1,1) & (2**np.arange(8))) != 0).astype(int)
B = B[:,::-1]
# Author: Daniel T. McDonald
I = np.array([0, 1, 2, 3, 15, 16, 32, 64, 128], dtype=np.uint8)
np.unpackbits(I[:, np.newaxis], axis=1)
Adept
=====
#. Consider an arbitrary array, write a function that extract a subpart with a
fixed shape and centered on a given element (pad with a ``fill`` value when
necessary)
.. code :: python
# Author: Nicolas Rougier
Z = np.random.random((25,25))
shape = (3,3)
fill = 0
position = (0,0)
R = np.ones(shape, dtype=Z.dtype)*fill
P = np.array(list(position)).astype(int)
Rs = np.array(list(R.shape)).astype(int)
Zs = np.array(list(Z.shape)).astype(int)
R_start = np.zeros((len(shape),)).astype(int)
R_stop = np.array(list(shape)).astype(int)
Z_start = (P-Rs//2)
Z_stop = (P+Rs//2)+Rs%2
R_start = (R_start - np.minimum(Z_start,0)).tolist()
Z_start = (np.maximum(Z_start,0)).tolist()
R_stop = np.maximum(R_start, (R_stop - np.maximum(Z_stop-Zs,0))).tolist()
Z_stop = (np.minimum(Z_stop,Zs)).tolist()
r = [slice(start,stop) for start,stop in zip(R_start,R_stop)]
z = [slice(start,stop) for start,stop in zip(Z_start,Z_stop)]
R[r] = Z[z]
Expert
======
#. Consider two arrays A and B of shape (8,3) and (2,2). How to find rows of A
that contain elements of each row of B regardless of the order of the elements
in B ?
.. code:: python
# Author: Gabe Schwartz
A = np.random.randint(0,5,(8,3))
B = np.random.randint(0,5,(2,2))
C = (A[..., np.newaxis, np.newaxis] == B)
rows = (C.sum(axis=(1,2,3)) >= B.shape[1]).nonzero()[0]
#. Extract all the contiguous 3x3 blocks from a random 10x10 matrix.
.. code:: python
Z = np.random.randint(0,5,(10,10))
n = 3
i = 1 + (Z.shape[0]-3)
j = 1 + (Z.shape[1]-3)
C = stride_tricks.as_strided(Z, shape=(i, j, n, n), strides=Z.strides + Z.strides)
Master
======
Archmaster
==========

356
numpy.css Normal file
View File

@@ -0,0 +1,356 @@
@import url("reset.css");
/* =========================================================================
* Body
* ========================================================================= */
body {
color: #333333;
font-family: "optima", "lucida grande", "lucida sans unicode",
verdana, arial, helvetica, sans-serif;
font-size: 1.1em;
line-height: 1.5em;
margin-top: 0em;
}
/* =========================================================================
* Document
* ========================================================================= */
div.document {
margin-top: 50px;
margin-bottom: 5em;
margin-left: 250px;
margin-right: 10%;
}
h1, h2, h3, h4, h5, h6 {
font-family: "futura", "lucida grande", "lucida sans unicode",
verdana, arial, helvetica, sans-serif;
font-weight: normal;
clear: both;
}
h1 {
font-size: 2em;
margin-top: 2em;
padding-top: 2em;
margin-bottom: 1em;
}
h2 {
font-size: 1.25em;
margin-top: 3em;
margin-bottom: 1em;
color: #326598;
padding-left: 2em;
margin-left: -2em;
margin-right: 25%;
padding-bottom: .5em;
padding-top: 2em;
border-bottom: 2px solid #326598;
}
h3 {
font-size: 1em;
margin-top: 3em;
margin-bottom: 1em;
border-bottom: 1px solid #efefef;
color: #326598;
}
h1.title {
margin-bottom: 0.0em;
padding-bottom: 0.0em;
}
h2.subtitle {
font-size: 1.0em;
padding-top: 0.5em;
margin-top: 0.0em;
color: #999;
border-bottom: none;
}
p {
margin-bottom: 1em;
}
strong {
font-weight: bold;
}
em {
font-style: italic;
}
a {
color: #326598;
text-decoration: none;
}
a:hover {
color: #326598;
text-decoration: underline;
}
hr {
margin-top: 1em;
border: 0;
}
.contents ul {
margin: 0;
padding: 0;
border: 0;
font-size: 100%;
font: inherit;
vertical-align: baseline;
list-style: none;
}
/* =========================================================================
* Image
* ========================================================================= */
img {
text-align : left;
}
.align-right {
float: right;
}
.aling-left {
float: left;
}
/* =========================================================================
* Figure
* ========================================================================= */
.figure
{
margin-top: 1em;
margin-bottom: 1em;
}
/* =========================================================================
* Math
* ========================================================================= */
img.math {
vertical-align: middle;
}
div.body div.math p {
text-align: left;
}
span.eqno {
float: right;
}
/* =========================================================================
* Table
* ========================================================================= */
table
{
margin-bottom: 2em;
}
th.head
{
font-weight: bold;
text-align: left;
border-bottom: 1px solid black;
padding-right: .5em;
}
th.field-name
{
font-weight: bold;
text-align: left;
padding-right: 1em;
}
td {
vertical-align:middle;
padding-bottom: 1em;
}
.compact-table td {
vertical-align:middle;
padding-bottom: .1em;
}
.compact-table {
width:100%;
}
/* =========================================================================
* Code
* ========================================================================= */
tt {
font-family: monospace;
}
pre {
background: #eeeeee;
border: 1px solid #cccccc;
padding: .5em;
line-height: 1.25em;
font-family: monospace;
margin-bottom: 1em;
width: 75%;
}
dl.docutils > dd {
margin-left: 2em;
/* font-size: 90%;*/
}
dl.docutils > dt {
font-style: italic;
color: #000099;
}
.classifier {
font-style: normal;
color: #000000;
}
.classifier-delimiter {
font-style: normal;
color: #000000;
}
dl > dt {
font-family: monospace;
}
dl.method, dl.attribute, dl.function, dl.class {
margin-bottom: 1em;
}
dl.class > dt, dl.function > dt, dl.method > dt, dl.attribute > dt {
padding: .25em;
margin-top: 2em;
background: #eeeeee;
}
.descname {
font-weight: bold;
}
/* =========================================================================
* Table of Contents
* ========================================================================= */
/* Global */
.toctree-wrapper {
padding-bottom: 3em;
}
.toctree-wrapper ul {
list-style-type:none;
padding-bottom: 0;
}
/*
.toctree-l1 {
margin-bottom: 1em;
}
*/
.toctree-l2 {
padding-left: 2em;
}
/* Local */
li > ul > li {
padding-left: 2em;
}
div.document .contents {
margin-bottom: 5em;
}
div.document .topic-title {
margin-top: 2em;
font-weight: bold;
}
.contents ul {
list-style-type:none;
padding-bottom: 0;
}
/* -------------------------------------------------------------------------
Admonition
------------------------------------------------------------------------- */
div.admonition, div.note {
float: left;
line-height: 1.5em;
font-size: 80%;
margin: 0;
padding: 3px 5px;
margin-left: -220px;
width: 200px;
border-left: 1px solid #cccccc;
}
div.admonition p, div.note p {
text-align: left;
margin: 0;
padding: 0;
}
div.admonition .first, div.note .first {
font-weight: bold;
}
/* -------------------------------------------------------------------------
Header
------------------------------------------------------------------------- */
div.header {
padding-top: 25px;
padding-left:15px;
}
/* -------------------------------------------------------------------------
Footer
------------------------------------------------------------------------- */
div.footer {
font-family: "futura", "lucida grande", "lucida sans unicode",
verdana, arial, helvetica, sans-serif;
font-size: 75%;
line-height: 1.5em;
position: fixed;
left: 0;
bottom: 0;
background-color: #EEE;
width: 100%;
border-top: 1px solid;
}
div.footer table {
width: 98%;
margin: auto;
}
div.footer table td a {
color: #777;
text-decoration: none;
}
div.footer td.left {
text-align: left;
width: 25%;
}
div.footer td.center {
text-align: center;
width: 50%;
}
div.footer .current {
background: black;
color:white;
margin: 0;
padding-right: .25em;
padding-left: .25em;
}
div.footer td.center a {
padding-right: .25em;
padding-left: .25em;
}
div.footer td.right {
text-align: right;
width: 25%;
}

35
reset.css Normal file
View File

@@ -0,0 +1,35 @@
/* http://meyerweb.com/eric/tools/css/reset/
v2.0 | 20110126
License: none (public domain)
*/
html, body, div, span, applet, object, iframe, h1, h2, h3, h4, h5, h6, p, blockquote, pre, a, abbr, acronym, address, big, cite, code, del, dfn, em, img, ins, kbd, q, s, samp, small, strike, strong, sub, sup, tt, var, b, u, i, center, dl, dt, dd, fieldset, form, label, legend, table, caption, tbody, tfoot, thead, tr, th, td, article, aside, canvas, details, embed, figure, figcaption, footer, header, hgroup, menu, nav, output, ruby, section, summary, time, mark, audio, video, ul, ol {
margin: 0;
padding: 0;
border: 0;
font-size: 100%;
font: inherit;
vertical-align: baseline;
}
/* HTML5 display-role reset for older browsers */
article, aside, details, figcaption, figure, footer, header, hgroup, menu, nav, section {
display: block;
}
body {
line-height: 1;
}
ul {
list-style: none;
}
blockquote, q {
quotes: none;
}
blockquote:before, blockquote:after, q:before, q:after {
content: '';
content: none;
}
table {
border-collapse: collapse;
border-spacing: 0;
}