[Numpy Beginner's Guide] Chapter_3.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import numpy as np"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 1
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a = np.eye(3)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 2
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "a"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 3,
       "text": [
        "array([[ 1.,  0.,  0.],\n",
        "\n",
        "       [ 0.,  1.,  0.],\n",
        "\n",
        "       [ 0.,  0.,  1.]])"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.savetxt('eye3.txt', a)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "c, v = np.loadtxt('data.csv', delimiter = ',', usecols = (6,7), unpack = True)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 7
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "c"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 8,
       "text": [
        "336.10000000000002"
       ]
      }
     ],
     "prompt_number": 8
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "v"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 9,
       "text": [
        "21144800.0"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.average(c, weights = v)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 10,
       "text": [
        "336.10000000000002"
       ]
      }
     ],
     "prompt_number": 10
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.average([1,2], weights = [2,1])"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 11,
       "text": [
        "1.3333333333333333"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.mean(c)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 12,
       "text": [
        "336.10000000000002"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "h = np.random.random(10)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 13
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "h"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 14,
       "text": [
        "array([ 0.49991699,  0.98879326,  0.73244113,  0.71491818,  0.27832583,\n",
        "\n",
        "        0.44523822,  0.21923464,  0.47292412,  0.53445413,  0.02747245])"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.max(h)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 15,
       "text": [
        "0.98879325783427785"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "h.max()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 16,
       "text": [
        "0.98879325783427785"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.ptp(h)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 17,
       "text": [
        "0.96132080595739156"
       ]
      }
     ],
     "prompt_number": 17
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.median(h)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 18,
       "text": [
        "0.48642055737504769"
       ]
      }
     ],
     "prompt_number": 18
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.sort(h)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 20,
       "text": [
        "array([ 0.02747245,  0.21923464,  0.27832583,  0.44523822,  0.47292412,\n",
        "\n",
        "        0.49991699,  0.53445413,  0.71491818,  0.73244113,  0.98879326])"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.var(h)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 21,
       "text": [
        "0.069456306901357415"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.mean((h - h.mean())**2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 22,
       "text": [
        "0.069456306901357415"
       ]
      }
     ],
     "prompt_number": 22
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "l = np.arange(1,12)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 23
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "l"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 24,
       "text": [
        "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])"
       ]
      }
     ],
     "prompt_number": 24
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.diff(l).astype('f')/l[:-1]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 28,
       "text": [
        "array([ 1.        ,  0.5       ,  0.33333333,  0.25      ,  0.2       ,\n",
        "\n",
        "        0.16666667,  0.14285714,  0.125     ,  0.11111111,  0.1       ])"
       ]
      }
     ],
     "prompt_number": 28
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.std(l)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 29,
       "text": [
        "3.1622776601683795"
       ]
      }
     ],
     "prompt_number": 29
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.log(h)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 30,
       "text": [
        "array([-0.69331321, -0.01127001, -0.3113723 , -0.33558718, -1.2789628 ,\n",
        "\n",
        "       -0.80914582, -1.51761271, -0.74882032, -0.62650938, -3.59457153])"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.where(h>0.5)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 31,
       "text": [
        "(array([1, 2, 3, 8]),)"
       ]
      }
     ],
     "prompt_number": 31
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def datestr2num(s):\n",
      "\n",
      "    return datetime.datetime.strptime(s, '%d-%m-%Y').date().weekday()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 34
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dates, close = np.loadtxt('data.csv', delimiter = ',', usecols = (1, 6), unpack = True, converters = {1: datestr2num})"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 35
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "dates"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 36,
       "text": [
        "4.0"
       ]
      }
     ],
     "prompt_number": 36
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.zeros(5)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 37,
       "text": [
        "array([ 0.,  0.,  0.,  0.,  0.])"
       ]
      }
     ],
     "prompt_number": 37
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "idx = np.where(h > 0.5)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 38
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.take(h, idx)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 39,
       "text": [
        "array([[ 0.98879326,  0.73244113,  0.71491818,  0.53445413]])"
       ]
      }
     ],
     "prompt_number": 39
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.argmin(h)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 40,
       "text": [
        "9"
       ]
      }
     ],
     "prompt_number": 40
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "idx = np.ravel(np.where(h>0.5))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 42
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.split(idx, 2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 43,
       "text": [
        "[array([1, 2]), array([3, 8])]"
       ]
      }
     ],
     "prompt_number": 43
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "help(np.apply_along_axis)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Help on function apply_along_axis in module numpy.lib.shape_base:\n",
        "\n",
        "\n",
        "\n",
        "apply_along_axis(func1d, axis, arr, *args)\n",
        "\n",
        "    Apply a function to 1-D slices along the given axis.\n",
        "\n",
        "    \n",
        "\n",
        "    Execute `func1d(a, *args)` where `func1d` operates on 1-D arrays and `a`\n",
        "\n",
        "    is a 1-D slice of `arr` along `axis`.\n",
        "\n",
        "    \n",
        "\n",
        "    Parameters\n",
        "\n",
        "    ----------\n",
        "\n",
        "    func1d : function\n",
        "\n",
        "        This function should accept 1-D arrays. It is applied to 1-D\n",
        "\n",
        "        slices of `arr` along the specified axis.\n",
        "\n",
        "    axis : integer\n",
        "\n",
        "        Axis along which `arr` is sliced.\n",
        "\n",
        "    arr : ndarray\n",
        "\n",
        "        Input array.\n",
        "\n",
        "    args : any\n",
        "\n",
        "        Additional arguments to `func1d`.\n",
        "\n",
        "    \n",
        "\n",
        "    Returns\n",
        "\n",
        "    -------\n",
        "\n",
        "    apply_along_axis : ndarray\n",
        "\n",
        "        The output array. The shape of `outarr` is identical to the shape of\n",
        "\n",
        "        `arr`, except along the `axis` dimension, where the length of `outarr`\n",
        "\n",
        "        is equal to the size of the return value of `func1d`.  If `func1d`\n",
        "\n",
        "        returns a scalar `outarr` will have one fewer dimensions than `arr`.\n",
        "\n",
        "    \n",
        "\n",
        "    See Also\n",
        "\n",
        "    --------\n",
        "\n",
        "    apply_over_axes : Apply a function repeatedly over multiple axes.\n",
        "\n",
        "    \n",
        "\n",
        "    Examples\n",
        "\n",
        "    --------\n",
        "\n",
        "    >>> def my_func(a):\n",
        "\n",
        "    ...     \"\"\"Average first and last element of a 1-D array\"\"\"\n",
        "\n",
        "    ...     return (a[0] + a[-1]) * 0.5\n",
        "\n",
        "    >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])\n",
        "\n",
        "    >>> np.apply_along_axis(my_func, 0, b)\n",
        "\n",
        "    array([ 4.,  5.,  6.])\n",
        "\n",
        "    >>> np.apply_along_axis(my_func, 1, b)\n",
        "\n",
        "    array([ 2.,  5.,  8.])\n",
        "\n",
        "    \n",
        "\n",
        "    For a function that doesn't return a scalar, the number of dimensions in\n",
        "\n",
        "    `outarr` is the same as `arr`.\n",
        "\n",
        "    \n",
        "\n",
        "    >>> def new_func(a):\n",
        "\n",
        "    ...     \"\"\"Divide elements of a by 2.\"\"\"\n",
        "\n",
        "    ...     return a * 0.5\n",
        "\n",
        "    >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])\n",
        "\n",
        "    >>> np.apply_along_axis(new_func, 0, b)\n",
        "\n",
        "    array([[ 0.5,  1. ,  1.5],\n",
        "\n",
        "           [ 2. ,  2.5,  3. ],\n",
        "\n",
        "           [ 3.5,  4. ,  4.5]])\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 45
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.savetxt('h.txt', h, delimiter = ',', fmt = '%s')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 47
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.where(np.arange(10) < 3)[0]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 50,
       "text": [
        "array([0, 1, 2])"
       ]
      }
     ],
     "prompt_number": 50
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "help(np.where)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Help on built-in function where in module numpy.core.multiarray:\n",
        "\n",
        "\n",
        "\n",
        "where(...)\n",
        "\n",
        "    where(condition, [x, y])\n",
        "\n",
        "    \n",
        "\n",
        "    Return elements, either from `x` or `y`, depending on `condition`.\n",
        "\n",
        "    \n",
        "\n",
        "    If only `condition` is given, return ``condition.nonzero()``.\n",
        "\n",
        "    \n",
        "\n",
        "    Parameters\n",
        "\n",
        "    ----------\n",
        "\n",
        "    condition : array_like, bool\n",
        "\n",
        "        When True, yield `x`, otherwise yield `y`.\n",
        "\n",
        "    x, y : array_like, optional\n",
        "\n",
        "        Values from which to choose. `x` and `y` need to have the same\n",
        "\n",
        "        shape as `condition`.\n",
        "\n",
        "    \n",
        "\n",
        "    Returns\n",
        "\n",
        "    -------\n",
        "\n",
        "    out : ndarray or tuple of ndarrays\n",
        "\n",
        "        If both `x` and `y` are specified, the output array contains\n",
        "\n",
        "        elements of `x` where `condition` is True, and elements from\n",
        "\n",
        "        `y` elsewhere.\n",
        "\n",
        "    \n",
        "\n",
        "        If only `condition` is given, return the tuple\n",
        "\n",
        "        ``condition.nonzero()``, the indices where `condition` is True.\n",
        "\n",
        "    \n",
        "\n",
        "    See Also\n",
        "\n",
        "    --------\n",
        "\n",
        "    nonzero, choose\n",
        "\n",
        "    \n",
        "\n",
        "    Notes\n",
        "\n",
        "    -----\n",
        "\n",
        "    If `x` and `y` are given and input arrays are 1-D, `where` is\n",
        "\n",
        "    equivalent to::\n",
        "\n",
        "    \n",
        "\n",
        "        [xv if c else yv for (c,xv,yv) in zip(condition,x,y)]\n",
        "\n",
        "    \n",
        "\n",
        "    Examples\n",
        "\n",
        "    --------\n",
        "\n",
        "    >>> np.where([[True, False], [True, True]],\n",
        "\n",
        "    ...          [[1, 2], [3, 4]],\n",
        "\n",
        "    ...          [[9, 8], [7, 6]])\n",
        "\n",
        "    array([[1, 8],\n",
        "\n",
        "           [3, 4]])\n",
        "\n",
        "    \n",
        "\n",
        "    >>> np.where([[0, 1], [1, 0]])\n",
        "\n",
        "    (array([0, 1]), array([1, 0]))\n",
        "\n",
        "    \n",
        "\n",
        "    >>> x = np.arange(9.).reshape(3, 3)\n",
        "\n",
        "    >>> np.where( x > 5 )\n",
        "\n",
        "    (array([2, 2, 2]), array([0, 1, 2]))\n",
        "\n",
        "    >>> x[np.where( x > 3.0 )]               # Note: result is 1D.\n",
        "\n",
        "    array([ 4.,  5.,  6.,  7.,  8.])\n",
        "\n",
        "    >>> np.where(x < 5, x, -1)               # Note: broadcasting.\n",
        "\n",
        "    array([[ 0.,  1.,  2.],\n",
        "\n",
        "           [ 3.,  4., -1.],\n",
        "\n",
        "           [-1., -1., -1.]])\n",
        "\n",
        "    \n",
        "\n",
        "    Find the indices of elements of `x` that are in `goodvalues`.\n",
        "\n",
        "    \n",
        "\n",
        "    >>> goodvalues = [3, 4, 7]\n",
        "\n",
        "    >>> ix = np.in1d(x.ravel(), goodvalues).reshape(x.shape)\n",
        "\n",
        "    >>> ix\n",
        "\n",
        "    array([[False, False, False],\n",
        "\n",
        "           [ True,  True, False],\n",
        "\n",
        "           [False,  True, False]], dtype=bool)\n",
        "\n",
        "    >>> np.where(ix)\n",
        "\n",
        "    (array([1, 1, 2]), array([0, 1, 1]))\n",
        "\n"
       ]
      }
     ],
     "prompt_number": 51
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.maximum(np.arange(3), np.arange(1,4), np.arange(2,5))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 52,
       "text": [
        "array([1, 2, 3])"
       ]
      }
     ],
     "prompt_number": 52
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.arange(2,5)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 53,
       "text": [
        "array([2, 3, 4])"
       ]
      }
     ],
     "prompt_number": 53
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "t = np.arange(10)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 56
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "w = np.ones(4)/4"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 55
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.convolve(w, t)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 60,
       "text": [
        "array([ 0.  ,  0.25,  0.75,  1.5 ,  2.5 ,  3.5 ,  4.5 ,  5.5 ,  6.5 ,\n",
        "\n",
        "        7.5 ,  6.  ,  4.25,  2.25])"
       ]
      }
     ],
     "prompt_number": 60
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "w"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 58,
       "text": [
        "array([ 0.25,  0.25,  0.25,  0.25])"
       ]
      }
     ],
     "prompt_number": 58
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.exp(w)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 61,
       "text": [
        "array([ 1.28402542,  1.28402542,  1.28402542,  1.28402542])"
       ]
      }
     ],
     "prompt_number": 61
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.linspace(0,1,5)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 62,
       "text": [
        "array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ])"
       ]
      }
     ],
     "prompt_number": 62
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "z = np.zeros(10)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 63
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "z.fill(0.5)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 64
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "z"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 65,
       "text": [
        "array([ 0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5,  0.5])"
       ]
      }
     ],
     "prompt_number": 65
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "z = np.random.random(10)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 66
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "z"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 67,
       "text": [
        "array([ 0.93510636,  0.4708436 ,  0.00878291,  0.33771497,  0.43101976,\n",
        "\n",
        "        0.49761005,  0.98533547,  0.56150324,  0.58119752,  0.80594386])"
       ]
      }
     ],
     "prompt_number": 67
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "A = np.zeros((5, 5))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 69
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for i in range(5):\n",
      "\n",
      "   A[i, :] = z[i:i+5]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 70
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "A"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 71,
       "text": [
        "array([[ 0.93510636,  0.4708436 ,  0.00878291,  0.33771497,  0.43101976],\n",
        "\n",
        "       [ 0.4708436 ,  0.00878291,  0.33771497,  0.43101976,  0.49761005],\n",
        "\n",
        "       [ 0.00878291,  0.33771497,  0.43101976,  0.49761005,  0.98533547],\n",
        "\n",
        "       [ 0.33771497,  0.43101976,  0.49761005,  0.98533547,  0.56150324],\n",
        "\n",
        "       [ 0.43101976,  0.49761005,  0.98533547,  0.56150324,  0.58119752]])"
       ]
      }
     ],
     "prompt_number": 71
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "b = z[5:]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 72
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "b"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 73,
       "text": [
        "array([ 0.49761005,  0.98533547,  0.56150324,  0.58119752,  0.80594386])"
       ]
      }
     ],
     "prompt_number": 73
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "x, residuals, rank, s = np.linalg.lstsq(A, b)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 75
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.dot(b, x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 77,
       "text": [
        "0.10689938687451071"
       ]
      }
     ],
     "prompt_number": 77
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "z1 = z[z>0.5]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 79
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "z2 = z[z<=0.7]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 81
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "np.intersect1d(z1, z2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 82,
       "text": [
        "array([ 0.56150324,  0.58119752])"
       ]
      }
     ],
     "prompt_number": 82
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "z = np.arange(10)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 83
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "z.clip(3, 8)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 85,
       "text": [
        "array([3, 3, 3, 3, 4, 5, 6, 7, 8, 8])"
       ]
      }
     ],
     "prompt_number": 85
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "z.compress(z>3)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 87,
       "text": [
        "array([4, 5, 6, 7, 8, 9])"
       ]
      }
     ],
     "prompt_number": 87
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "z[z>3]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 88,
       "text": [
        "array([4, 5, 6, 7, 8, 9])"
       ]
      }
     ],
     "prompt_number": 88
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "z = np.arange(1,5)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 89
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "z"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 90,
       "text": [
        "array([1, 2, 3, 4])"
       ]
      }
     ],
     "prompt_number": 90
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "z.prod()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 91,
       "text": [
        "24"
       ]
      }
     ],
     "prompt_number": 91
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "z.cumprod()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "pyout",
       "prompt_number": 92,
       "text": [
        "array([ 1,  2,  6, 24])"
       ]
      }
     ],
     "prompt_number": 92
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}