FFT_with_numpy_scipy_skcuda.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "import datetime\n",
    "import numpy as np\n",
    "import scipy as sp\n",
    "import scipy.fftpack\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "df0 = pd.read_csv('data/weather.csv',\n",
    "na_values=(-9999),\n",
    "parse_dates=['DATE'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "df = df0[df0['DATE']>='19940101']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>STATION</th>\n",
       "      <th>DATE</th>\n",
       "      <th>PRCP</th>\n",
       "      <th>TMAX</th>\n",
       "      <th>TMIN</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>365</th>\n",
       "      <td>GHCND:FR013055001</td>\n",
       "      <td>1994-01-01</td>\n",
       "      <td>0.0</td>\n",
       "      <td>104.0</td>\n",
       "      <td>72.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>366</th>\n",
       "      <td>GHCND:FR013055001</td>\n",
       "      <td>1994-01-02</td>\n",
       "      <td>4.0</td>\n",
       "      <td>128.0</td>\n",
       "      <td>49.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>367</th>\n",
       "      <td>GHCND:FR013055001</td>\n",
       "      <td>1994-01-03</td>\n",
       "      <td>0.0</td>\n",
       "      <td>160.0</td>\n",
       "      <td>87.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>368</th>\n",
       "      <td>GHCND:FR013055001</td>\n",
       "      <td>1994-01-04</td>\n",
       "      <td>0.0</td>\n",
       "      <td>118.0</td>\n",
       "      <td>83.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>369</th>\n",
       "      <td>GHCND:FR013055001</td>\n",
       "      <td>1994-01-05</td>\n",
       "      <td>34.0</td>\n",
       "      <td>133.0</td>\n",
       "      <td>55.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               STATION       DATE  PRCP   TMAX  TMIN\n",
       "365  GHCND:FR013055001 1994-01-01   0.0  104.0  72.0\n",
       "366  GHCND:FR013055001 1994-01-02   4.0  128.0  49.0\n",
       "367  GHCND:FR013055001 1994-01-03   0.0  160.0  87.0\n",
       "368  GHCND:FR013055001 1994-01-04   0.0  118.0  83.0\n",
       "369  GHCND:FR013055001 1994-01-05  34.0  133.0  55.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "df_avg = df.dropna().groupby('DATE').mean()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>PRCP</th>\n",
       "      <th>TMAX</th>\n",
       "      <th>TMIN</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>DATE</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1994-01-01</th>\n",
       "      <td>178.666667</td>\n",
       "      <td>127.388889</td>\n",
       "      <td>70.333333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1994-01-02</th>\n",
       "      <td>122.000000</td>\n",
       "      <td>152.421053</td>\n",
       "      <td>81.736842</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1994-01-03</th>\n",
       "      <td>277.333333</td>\n",
       "      <td>157.666667</td>\n",
       "      <td>95.555556</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1994-01-04</th>\n",
       "      <td>177.105263</td>\n",
       "      <td>142.210526</td>\n",
       "      <td>95.684211</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1994-01-05</th>\n",
       "      <td>117.944444</td>\n",
       "      <td>130.222222</td>\n",
       "      <td>75.444444</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  PRCP        TMAX       TMIN\n",
       "DATE                                         \n",
       "1994-01-01  178.666667  127.388889  70.333333\n",
       "1994-01-02  122.000000  152.421053  81.736842\n",
       "1994-01-03  277.333333  157.666667  95.555556\n",
       "1994-01-04  177.105263  142.210526  95.684211\n",
       "1994-01-05  117.944444  130.222222  75.444444"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_avg.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "date = df_avg.index.to_datetime()\n",
    "temp = (df_avg['TMAX'] + df_avg['TMIN']) / 20.\n",
    "N = len(temp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "temp2 = np.array(temp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  9.88611111,  11.70789474,  12.66111111, ...,   8.56111111,\n",
       "         8.43333333,   6.55      ])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.text.Text at 0x7fb8c9f3eba8>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEKCAYAAAAMzhLIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fb8c9e2ef28>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot_date(date, temp, '-', lw=.5)\n",
    "plt.ylim(-10, 40)\n",
    "plt.xlabel('Date')\n",
    "plt.ylabel('Mean temperature')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "temp_fft = sp.fftpack.fft(temp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7282,)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on package scipy.fftpack in scipy:\n",
      "\n",
      "NAME\n",
      "    scipy.fftpack\n",
      "\n",
      "DESCRIPTION\n",
      "    ==================================================\n",
      "    Discrete Fourier transforms (:mod:`scipy.fftpack`)\n",
      "    ==================================================\n",
      "    \n",
      "    Fast Fourier Transforms (FFTs)\n",
      "    ==============================\n",
      "    \n",
      "    .. autosummary::\n",
      "       :toctree: generated/\n",
      "    \n",
      "       fft - Fast (discrete) Fourier Transform (FFT)\n",
      "       ifft - Inverse FFT\n",
      "       fft2 - Two dimensional FFT\n",
      "       ifft2 - Two dimensional inverse FFT\n",
      "       fftn - n-dimensional FFT\n",
      "       ifftn - n-dimensional inverse FFT\n",
      "       rfft - FFT of strictly real-valued sequence\n",
      "       irfft - Inverse of rfft\n",
      "       dct - Discrete cosine transform\n",
      "       idct - Inverse discrete cosine transform\n",
      "       dst - Discrete sine transform\n",
      "       idst - Inverse discrete sine transform\n",
      "    \n",
      "    Differential and pseudo-differential operators\n",
      "    ==============================================\n",
      "    \n",
      "    .. autosummary::\n",
      "       :toctree: generated/\n",
      "    \n",
      "       diff - Differentiation and integration of periodic sequences\n",
      "       tilbert - Tilbert transform:         cs_diff(x,h,h)\n",
      "       itilbert - Inverse Tilbert transform: sc_diff(x,h,h)\n",
      "       hilbert - Hilbert transform:         cs_diff(x,inf,inf)\n",
      "       ihilbert - Inverse Hilbert transform: sc_diff(x,inf,inf)\n",
      "       cs_diff - cosh/sinh pseudo-derivative of periodic sequences\n",
      "       sc_diff - sinh/cosh pseudo-derivative of periodic sequences\n",
      "       ss_diff - sinh/sinh pseudo-derivative of periodic sequences\n",
      "       cc_diff - cosh/cosh pseudo-derivative of periodic sequences\n",
      "       shift - Shift periodic sequences\n",
      "    \n",
      "    Helper functions\n",
      "    ================\n",
      "    \n",
      "    .. autosummary::\n",
      "       :toctree: generated/\n",
      "    \n",
      "       fftshift - Shift the zero-frequency component to the center of the spectrum\n",
      "       ifftshift - The inverse of `fftshift`\n",
      "       fftfreq - Return the Discrete Fourier Transform sample frequencies\n",
      "       rfftfreq - DFT sample frequencies (for usage with rfft, irfft)\n",
      "       next_fast_len - Find the optimal length to zero-pad an FFT for speed\n",
      "    \n",
      "    Note that ``fftshift``, ``ifftshift`` and ``fftfreq`` are numpy functions\n",
      "    exposed by ``fftpack``; importing them from ``numpy`` should be preferred.\n",
      "    \n",
      "    Convolutions (:mod:`scipy.fftpack.convolve`)\n",
      "    ============================================\n",
      "    \n",
      "    .. module:: scipy.fftpack.convolve\n",
      "    \n",
      "    .. autosummary::\n",
      "       :toctree: generated/\n",
      "    \n",
      "       convolve\n",
      "       convolve_z\n",
      "       init_convolution_kernel\n",
      "       destroy_convolve_cache\n",
      "\n",
      "PACKAGE CONTENTS\n",
      "    _fftpack\n",
      "    basic\n",
      "    convolve\n",
      "    fftpack_version\n",
      "    helper\n",
      "    pseudo_diffs\n",
      "    realtransforms\n",
      "    setup\n",
      "\n",
      "FUNCTIONS\n",
      "    cc_diff(x, a, b, period=None, _cache={})\n",
      "        Return (a,b)-cosh/cosh pseudo-derivative of a periodic sequence.\n",
      "        \n",
      "        If x_j and y_j are Fourier coefficients of periodic functions x\n",
      "        and y, respectively, then::\n",
      "        \n",
      "          y_j = cosh(j*a*2*pi/period)/cosh(j*b*2*pi/period) * x_j\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            The array to take the pseudo-derivative from.\n",
      "        a,b : float\n",
      "            Defines the parameters of the sinh/sinh pseudo-differential\n",
      "            operator.\n",
      "        period : float, optional\n",
      "            The period of the sequence x. Default is ``2*pi``.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        cc_diff : ndarray\n",
      "            Pseudo-derivative of periodic sequence `x`.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        ``cc_diff(cc_diff(x,a,b),b,a) == x``\n",
      "    \n",
      "    cs_diff(x, a, b, period=None, _cache={})\n",
      "        Return (a,b)-cosh/sinh pseudo-derivative of a periodic sequence.\n",
      "        \n",
      "        If ``x_j`` and ``y_j`` are Fourier coefficients of periodic functions x\n",
      "        and y, respectively, then::\n",
      "        \n",
      "          y_j = -sqrt(-1)*cosh(j*a*2*pi/period)/sinh(j*b*2*pi/period) * x_j\n",
      "          y_0 = 0\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            The array to take the pseudo-derivative from.\n",
      "        a, b : float\n",
      "            Defines the parameters of the cosh/sinh pseudo-differential\n",
      "            operator.\n",
      "        period : float, optional\n",
      "            The period of the sequence. Default period is ``2*pi``.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        cs_diff : ndarray\n",
      "            Pseudo-derivative of periodic sequence `x`.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        For even len(`x`), the Nyquist mode of `x` is taken as zero.\n",
      "    \n",
      "    dct(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False)\n",
      "        Return the Discrete Cosine Transform of arbitrary type sequence x.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            The input array.\n",
      "        type : {1, 2, 3}, optional\n",
      "            Type of the DCT (see Notes). Default type is 2.\n",
      "        n : int, optional\n",
      "            Length of the transform.  If ``n < x.shape[axis]``, `x` is\n",
      "            truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The\n",
      "            default results in ``n = x.shape[axis]``.\n",
      "        axis : int, optional\n",
      "            Axis along which the dct is computed; the default is over the\n",
      "            last axis (i.e., ``axis=-1``).\n",
      "        norm : {None, 'ortho'}, optional\n",
      "            Normalization mode (see Notes). Default is None.\n",
      "        overwrite_x : bool, optional\n",
      "            If True, the contents of `x` can be destroyed; the default is False.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        y : ndarray of real\n",
      "            The transformed input array.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        idct : Inverse DCT\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        For a single dimension array ``x``, ``dct(x, norm='ortho')`` is equal to\n",
      "        MATLAB ``dct(x)``.\n",
      "        \n",
      "        There are theoretically 8 types of the DCT, only the first 3 types are\n",
      "        implemented in scipy. 'The' DCT generally refers to DCT type 2, and 'the'\n",
      "        Inverse DCT generally refers to DCT type 3.\n",
      "        \n",
      "        **Type I**\n",
      "        \n",
      "        There are several definitions of the DCT-I; we use the following\n",
      "        (for ``norm=None``)::\n",
      "        \n",
      "                                             N-2\n",
      "          y[k] = x[0] + (-1)**k x[N-1] + 2 * sum x[n]*cos(pi*k*n/(N-1))\n",
      "                                             n=1\n",
      "        \n",
      "        Only None is supported as normalization mode for DCT-I. Note also that the\n",
      "        DCT-I is only supported for input size > 1\n",
      "        \n",
      "        **Type II**\n",
      "        \n",
      "        There are several definitions of the DCT-II; we use the following\n",
      "        (for ``norm=None``)::\n",
      "        \n",
      "        \n",
      "                    N-1\n",
      "          y[k] = 2* sum x[n]*cos(pi*k*(2n+1)/(2*N)), 0 <= k < N.\n",
      "                    n=0\n",
      "        \n",
      "        If ``norm='ortho'``, ``y[k]`` is multiplied by a scaling factor `f`::\n",
      "        \n",
      "          f = sqrt(1/(4*N)) if k = 0,\n",
      "          f = sqrt(1/(2*N)) otherwise.\n",
      "        \n",
      "        Which makes the corresponding matrix of coefficients orthonormal\n",
      "        (``OO' = Id``).\n",
      "        \n",
      "        **Type III**\n",
      "        \n",
      "        There are several definitions, we use the following\n",
      "        (for ``norm=None``)::\n",
      "        \n",
      "                            N-1\n",
      "          y[k] = x[0] + 2 * sum x[n]*cos(pi*(k+0.5)*n/N), 0 <= k < N.\n",
      "                            n=1\n",
      "        \n",
      "        or, for ``norm='ortho'`` and 0 <= k < N::\n",
      "        \n",
      "                                              N-1\n",
      "          y[k] = x[0] / sqrt(N) + sqrt(2/N) * sum x[n]*cos(pi*(k+0.5)*n/N)\n",
      "                                              n=1\n",
      "        \n",
      "        The (unnormalized) DCT-III is the inverse of the (unnormalized) DCT-II, up\n",
      "        to a factor `2N`. The orthonormalized DCT-III is exactly the inverse of\n",
      "        the orthonormalized DCT-II.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] 'A Fast Cosine Transform in One and Two Dimensions', by J.\n",
      "               Makhoul, `IEEE Transactions on acoustics, speech and signal\n",
      "               processing` vol. 28(1), pp. 27-34,\n",
      "               http://dx.doi.org/10.1109/TASSP.1980.1163351 (1980).\n",
      "        .. [2] Wikipedia, \"Discrete cosine transform\",\n",
      "               http://en.wikipedia.org/wiki/Discrete_cosine_transform\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        The Type 1 DCT is equivalent to the FFT (though faster) for real,\n",
      "        even-symmetrical inputs.  The output is also real and even-symmetrical.\n",
      "        Half of the FFT input is used to generate half of the FFT output:\n",
      "        \n",
      "        >>> from scipy.fftpack import fft, dct\n",
      "        >>> fft(np.array([4., 3., 5., 10., 5., 3.])).real\n",
      "        array([ 30.,  -8.,   6.,  -2.,   6.,  -8.])\n",
      "        >>> dct(np.array([4., 3., 5., 10.]), 1)\n",
      "        array([ 30.,  -8.,   6.,  -2.])\n",
      "    \n",
      "    diff(x, order=1, period=None, _cache={})\n",
      "        Return k-th derivative (or integral) of a periodic sequence x.\n",
      "        \n",
      "        If x_j and y_j are Fourier coefficients of periodic functions x\n",
      "        and y, respectively, then::\n",
      "        \n",
      "          y_j = pow(sqrt(-1)*j*2*pi/period, order) * x_j\n",
      "          y_0 = 0 if order is not 0.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            Input array.\n",
      "        order : int, optional\n",
      "            The order of differentiation. Default order is 1. If order is\n",
      "            negative, then integration is carried out under the assumption\n",
      "            that ``x_0 == 0``.\n",
      "        period : float, optional\n",
      "            The assumed period of the sequence. Default is ``2*pi``.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        If ``sum(x, axis=0) = 0`` then ``diff(diff(x, k), -k) == x`` (within\n",
      "        numerical accuracy).\n",
      "        \n",
      "        For odd order and even ``len(x)``, the Nyquist mode is taken zero.\n",
      "    \n",
      "    dst(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False)\n",
      "        Return the Discrete Sine Transform of arbitrary type sequence x.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            The input array.\n",
      "        type : {1, 2, 3}, optional\n",
      "            Type of the DST (see Notes). Default type is 2.\n",
      "        n : int, optional\n",
      "            Length of the transform.  If ``n < x.shape[axis]``, `x` is\n",
      "            truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The\n",
      "            default results in ``n = x.shape[axis]``.\n",
      "        axis : int, optional\n",
      "            Axis along which the dst is computed; the default is over the\n",
      "            last axis (i.e., ``axis=-1``).\n",
      "        norm : {None, 'ortho'}, optional\n",
      "            Normalization mode (see Notes). Default is None.\n",
      "        overwrite_x : bool, optional\n",
      "            If True, the contents of `x` can be destroyed; the default is False.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        dst : ndarray of reals\n",
      "            The transformed input array.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        idst : Inverse DST\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        For a single dimension array ``x``.\n",
      "        \n",
      "        There are theoretically 8 types of the DST for different combinations of\n",
      "        even/odd boundary conditions and boundary off sets [1]_, only the first\n",
      "        3 types are implemented in scipy.\n",
      "        \n",
      "        **Type I**\n",
      "        \n",
      "        There are several definitions of the DST-I; we use the following\n",
      "        for ``norm=None``.  DST-I assumes the input is odd around n=-1 and n=N. ::\n",
      "        \n",
      "                     N-1\n",
      "          y[k] = 2 * sum x[n]*sin(pi*(k+1)*(n+1)/(N+1))\n",
      "                     n=0\n",
      "        \n",
      "        Only None is supported as normalization mode for DCT-I. Note also that the\n",
      "        DCT-I is only supported for input size > 1\n",
      "        The (unnormalized) DCT-I is its own inverse, up to a factor `2(N+1)`.\n",
      "        \n",
      "        **Type II**\n",
      "        \n",
      "        There are several definitions of the DST-II; we use the following\n",
      "        for ``norm=None``.  DST-II assumes the input is odd around n=-1/2 and\n",
      "        n=N-1/2; the output is odd around k=-1 and even around k=N-1 ::\n",
      "        \n",
      "                    N-1\n",
      "          y[k] = 2* sum x[n]*sin(pi*(k+1)*(n+0.5)/N), 0 <= k < N.\n",
      "                    n=0\n",
      "        \n",
      "        if ``norm='ortho'``, ``y[k]`` is multiplied by a scaling factor `f` ::\n",
      "        \n",
      "            f = sqrt(1/(4*N)) if k == 0\n",
      "            f = sqrt(1/(2*N)) otherwise.\n",
      "        \n",
      "        **Type III**\n",
      "        \n",
      "        There are several definitions of the DST-III, we use the following\n",
      "        (for ``norm=None``).  DST-III assumes the input is odd around n=-1\n",
      "        and even around n=N-1 ::\n",
      "        \n",
      "                                     N-2\n",
      "          y[k] = x[N-1]*(-1)**k + 2* sum x[n]*sin(pi*(k+0.5)*(n+1)/N), 0 <= k < N.\n",
      "                                     n=0\n",
      "        \n",
      "        The (unnormalized) DCT-III is the inverse of the (unnormalized) DCT-II, up\n",
      "        to a factor `2N`.  The orthonormalized DST-III is exactly the inverse of\n",
      "        the orthonormalized DST-II.\n",
      "        \n",
      "        .. versionadded:: 0.11.0\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Wikipedia, \"Discrete sine transform\",\n",
      "               http://en.wikipedia.org/wiki/Discrete_sine_transform\n",
      "    \n",
      "    fft(x, n=None, axis=-1, overwrite_x=False)\n",
      "        Return discrete Fourier transform of real or complex sequence.\n",
      "        \n",
      "        The returned complex array contains ``y(0), y(1),..., y(n-1)`` where\n",
      "        \n",
      "        ``y(j) = (x * exp(-2*pi*sqrt(-1)*j*np.arange(n)/n)).sum()``.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            Array to Fourier transform.\n",
      "        n : int, optional\n",
      "            Length of the Fourier transform.  If ``n < x.shape[axis]``, `x` is\n",
      "            truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The\n",
      "            default results in ``n = x.shape[axis]``.\n",
      "        axis : int, optional\n",
      "            Axis along which the fft's are computed; the default is over the\n",
      "            last axis (i.e., ``axis=-1``).\n",
      "        overwrite_x : bool, optional\n",
      "            If True, the contents of `x` can be destroyed; the default is False.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        z : complex ndarray\n",
      "            with the elements::\n",
      "        \n",
      "                [y(0),y(1),..,y(n/2),y(1-n/2),...,y(-1)]        if n is even\n",
      "                [y(0),y(1),..,y((n-1)/2),y(-(n-1)/2),...,y(-1)]  if n is odd\n",
      "        \n",
      "            where::\n",
      "        \n",
      "                y(j) = sum[k=0..n-1] x[k] * exp(-sqrt(-1)*j*k* 2*pi/n), j = 0..n-1\n",
      "        \n",
      "            Note that ``y(-j) = y(n-j).conjugate()``.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        ifft : Inverse FFT\n",
      "        rfft : FFT of a real sequence\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The packing of the result is \"standard\": If ``A = fft(a, n)``, then\n",
      "        ``A[0]`` contains the zero-frequency term, ``A[1:n/2]`` contains the\n",
      "        positive-frequency terms, and ``A[n/2:]`` contains the negative-frequency\n",
      "        terms, in order of decreasingly negative frequency. So for an 8-point\n",
      "        transform, the frequencies of the result are [0, 1, 2, 3, -4, -3, -2, -1].\n",
      "        To rearrange the fft output so that the zero-frequency component is\n",
      "        centered, like [-4, -3, -2, -1,  0,  1,  2,  3], use `fftshift`.\n",
      "        \n",
      "        For `n` even, ``A[n/2]`` contains the sum of the positive and\n",
      "        negative-frequency terms.  For `n` even and `x` real, ``A[n/2]`` will\n",
      "        always be real.\n",
      "        \n",
      "        Both single and double precision routines are implemented.  Half precision\n",
      "        inputs will be converted to single precision.  Non floating-point inputs\n",
      "        will be converted to double precision.  Long-double precision inputs are\n",
      "        not supported.\n",
      "        \n",
      "        This function is most efficient when `n` is a power of two, and least\n",
      "        efficient when `n` is prime.\n",
      "        \n",
      "        If the data type of `x` is real, a \"real FFT\" algorithm is automatically\n",
      "        used, which roughly halves the computation time.  To increase efficiency\n",
      "        a little further, use `rfft`, which does the same calculation, but only\n",
      "        outputs half of the symmetrical spectrum.  If the data is both real and\n",
      "        symmetrical, the `dct` can again double the efficiency, by generating\n",
      "        half of the spectrum from half of the signal.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> from scipy.fftpack import fft, ifft\n",
      "        >>> x = np.arange(5)\n",
      "        >>> np.allclose(fft(ifft(x)), x, atol=1e-15)  # within numerical accuracy.\n",
      "        True\n",
      "    \n",
      "    fft2(x, shape=None, axes=(-2, -1), overwrite_x=False)\n",
      "        2-D discrete Fourier transform.\n",
      "        \n",
      "        Return the two-dimensional discrete Fourier transform of the 2-D argument\n",
      "        `x`.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        fftn : for detailed information.\n",
      "    \n",
      "    fftfreq(n, d=1.0)\n",
      "        Return the Discrete Fourier Transform sample frequencies.\n",
      "        \n",
      "        The returned float array `f` contains the frequency bin centers in cycles\n",
      "        per unit of the sample spacing (with zero at the start).  For instance, if\n",
      "        the sample spacing is in seconds, then the frequency unit is cycles/second.\n",
      "        \n",
      "        Given a window length `n` and a sample spacing `d`::\n",
      "        \n",
      "          f = [0, 1, ...,   n/2-1,     -n/2, ..., -1] / (d*n)   if n is even\n",
      "          f = [0, 1, ..., (n-1)/2, -(n-1)/2, ..., -1] / (d*n)   if n is odd\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        n : int\n",
      "            Window length.\n",
      "        d : scalar, optional\n",
      "            Sample spacing (inverse of the sampling rate). Defaults to 1.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        f : ndarray\n",
      "            Array of length `n` containing the sample frequencies.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> signal = np.array([-2, 8, 6, 4, 1, 0, 3, 5], dtype=float)\n",
      "        >>> fourier = np.fft.fft(signal)\n",
      "        >>> n = signal.size\n",
      "        >>> timestep = 0.1\n",
      "        >>> freq = np.fft.fftfreq(n, d=timestep)\n",
      "        >>> freq\n",
      "        array([ 0.  ,  1.25,  2.5 ,  3.75, -5.  , -3.75, -2.5 , -1.25])\n",
      "    \n",
      "    fftn(x, shape=None, axes=None, overwrite_x=False)\n",
      "        Return multidimensional discrete Fourier transform.\n",
      "        \n",
      "        The returned array contains::\n",
      "        \n",
      "          y[j_1,..,j_d] = sum[k_1=0..n_1-1, ..., k_d=0..n_d-1]\n",
      "             x[k_1,..,k_d] * prod[i=1..d] exp(-sqrt(-1)*2*pi/n_i * j_i * k_i)\n",
      "        \n",
      "        where d = len(x.shape) and n = x.shape.\n",
      "        Note that ``y[..., -j_i, ...] = y[..., n_i-j_i, ...].conjugate()``.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            The (n-dimensional) array to transform.\n",
      "        shape : tuple of ints, optional\n",
      "            The shape of the result.  If both `shape` and `axes` (see below) are\n",
      "            None, `shape` is ``x.shape``; if `shape` is None but `axes` is\n",
      "            not None, then `shape` is ``scipy.take(x.shape, axes, axis=0)``.\n",
      "            If ``shape[i] > x.shape[i]``, the i-th dimension is padded with zeros.\n",
      "            If ``shape[i] < x.shape[i]``, the i-th dimension is truncated to\n",
      "            length ``shape[i]``.\n",
      "        axes : array_like of ints, optional\n",
      "            The axes of `x` (`y` if `shape` is not None) along which the\n",
      "            transform is applied.\n",
      "        overwrite_x : bool, optional\n",
      "            If True, the contents of `x` can be destroyed.  Default is False.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        y : complex-valued n-dimensional numpy array\n",
      "            The (n-dimensional) DFT of the input array.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        ifftn\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Both single and double precision routines are implemented.  Half precision\n",
      "        inputs will be converted to single precision.  Non floating-point inputs\n",
      "        will be converted to double precision.  Long-double precision inputs are\n",
      "        not supported.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> from scipy.fftpack import fftn, ifftn\n",
      "        >>> y = (-np.arange(16), 8 - np.arange(16), np.arange(16))\n",
      "        >>> np.allclose(y, fftn(ifftn(y)))\n",
      "        True\n",
      "    \n",
      "    fftshift(x, axes=None)\n",
      "        Shift the zero-frequency component to the center of the spectrum.\n",
      "        \n",
      "        This function swaps half-spaces for all axes listed (defaults to all).\n",
      "        Note that ``y[0]`` is the Nyquist component only if ``len(x)`` is even.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            Input array.\n",
      "        axes : int or shape tuple, optional\n",
      "            Axes over which to shift.  Default is None, which shifts all axes.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        y : ndarray\n",
      "            The shifted array.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        ifftshift : The inverse of `fftshift`.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> freqs = np.fft.fftfreq(10, 0.1)\n",
      "        >>> freqs\n",
      "        array([ 0.,  1.,  2.,  3.,  4., -5., -4., -3., -2., -1.])\n",
      "        >>> np.fft.fftshift(freqs)\n",
      "        array([-5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.])\n",
      "        \n",
      "        Shift the zero-frequency component only along the second axis:\n",
      "        \n",
      "        >>> freqs = np.fft.fftfreq(9, d=1./9).reshape(3, 3)\n",
      "        >>> freqs\n",
      "        array([[ 0.,  1.,  2.],\n",
      "               [ 3.,  4., -4.],\n",
      "               [-3., -2., -1.]])\n",
      "        >>> np.fft.fftshift(freqs, axes=(1,))\n",
      "        array([[ 2.,  0.,  1.],\n",
      "               [-4.,  3.,  4.],\n",
      "               [-1., -3., -2.]])\n",
      "    \n",
      "    hilbert(x, _cache={})\n",
      "        Return Hilbert transform of a periodic sequence x.\n",
      "        \n",
      "        If x_j and y_j are Fourier coefficients of periodic functions x\n",
      "        and y, respectively, then::\n",
      "        \n",
      "          y_j = sqrt(-1)*sign(j) * x_j\n",
      "          y_0 = 0\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            The input array, should be periodic.\n",
      "        _cache : dict, optional\n",
      "            Dictionary that contains the kernel used to do a convolution with.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        y : ndarray\n",
      "            The transformed input.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.signal.hilbert : Compute the analytic signal, using the Hilbert\n",
      "                               transform.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        If ``sum(x, axis=0) == 0`` then ``hilbert(ihilbert(x)) == x``.\n",
      "        \n",
      "        For even len(x), the Nyquist mode of x is taken zero.\n",
      "        \n",
      "        The sign of the returned transform does not have a factor -1 that is more\n",
      "        often than not found in the definition of the Hilbert transform.  Note also\n",
      "        that `scipy.signal.hilbert` does have an extra -1 factor compared to this\n",
      "        function.\n",
      "    \n",
      "    idct(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False)\n",
      "        Return the Inverse Discrete Cosine Transform of an arbitrary type sequence.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            The input array.\n",
      "        type : {1, 2, 3}, optional\n",
      "            Type of the DCT (see Notes). Default type is 2.\n",
      "        n : int, optional\n",
      "            Length of the transform.  If ``n < x.shape[axis]``, `x` is\n",
      "            truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The\n",
      "            default results in ``n = x.shape[axis]``.\n",
      "        axis : int, optional\n",
      "            Axis along which the idct is computed; the default is over the\n",
      "            last axis (i.e., ``axis=-1``).\n",
      "        norm : {None, 'ortho'}, optional\n",
      "            Normalization mode (see Notes). Default is None.\n",
      "        overwrite_x : bool, optional\n",
      "            If True, the contents of `x` can be destroyed; the default is False.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        idct : ndarray of real\n",
      "            The transformed input array.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        dct : Forward DCT\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        For a single dimension array `x`, ``idct(x, norm='ortho')`` is equal to\n",
      "        MATLAB ``idct(x)``.\n",
      "        \n",
      "        'The' IDCT is the IDCT of type 2, which is the same as DCT of type 3.\n",
      "        \n",
      "        IDCT of type 1 is the DCT of type 1, IDCT of type 2 is the DCT of type\n",
      "        3, and IDCT of type 3 is the DCT of type 2. For the definition of these\n",
      "        types, see `dct`.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        The Type 1 DCT is equivalent to the DFT for real, even-symmetrical\n",
      "        inputs.  The output is also real and even-symmetrical.  Half of the IFFT\n",
      "        input is used to generate half of the IFFT output:\n",
      "        \n",
      "        >>> from scipy.fftpack import ifft, idct\n",
      "        >>> ifft(np.array([ 30.,  -8.,   6.,  -2.,   6.,  -8.])).real\n",
      "        array([  4.,   3.,   5.,  10.,   5.,   3.])\n",
      "        >>> idct(np.array([ 30.,  -8.,   6.,  -2.]), 1) / 6\n",
      "        array([  4.,   3.,   5.,  10.])\n",
      "    \n",
      "    idst(x, type=2, n=None, axis=-1, norm=None, overwrite_x=False)\n",
      "        Return the Inverse Discrete Sine Transform of an arbitrary type sequence.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            The input array.\n",
      "        type : {1, 2, 3}, optional\n",
      "            Type of the DST (see Notes). Default type is 2.\n",
      "        n : int, optional\n",
      "            Length of the transform.  If ``n < x.shape[axis]``, `x` is\n",
      "            truncated.  If ``n > x.shape[axis]``, `x` is zero-padded. The\n",
      "            default results in ``n = x.shape[axis]``.\n",
      "        axis : int, optional\n",
      "            Axis along which the idst is computed; the default is over the\n",
      "            last axis (i.e., ``axis=-1``).\n",
      "        norm : {None, 'ortho'}, optional\n",
      "            Normalization mode (see Notes). Default is None.\n",
      "        overwrite_x : bool, optional\n",
      "            If True, the contents of `x` can be destroyed; the default is False.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        idst : ndarray of real\n",
      "            The transformed input array.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        dst : Forward DST\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        'The' IDST is the IDST of type 2, which is the same as DST of type 3.\n",
      "        \n",
      "        IDST of type 1 is the DST of type 1, IDST of type 2 is the DST of type\n",
      "        3, and IDST of type 3 is the DST of type 2. For the definition of these\n",
      "        types, see `dst`.\n",
      "        \n",
      "        .. versionadded:: 0.11.0\n",
      "    \n",
      "    ifft(x, n=None, axis=-1, overwrite_x=False)\n",
      "        Return discrete inverse Fourier transform of real or complex sequence.\n",
      "        \n",
      "        The returned complex array contains ``y(0), y(1),..., y(n-1)`` where\n",
      "        \n",
      "        ``y(j) = (x * exp(2*pi*sqrt(-1)*j*np.arange(n)/n)).mean()``.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            Transformed data to invert.\n",
      "        n : int, optional\n",
      "            Length of the inverse Fourier transform.  If ``n < x.shape[axis]``,\n",
      "            `x` is truncated.  If ``n > x.shape[axis]``, `x` is zero-padded.\n",
      "            The default results in ``n = x.shape[axis]``.\n",
      "        axis : int, optional\n",
      "            Axis along which the ifft's are computed; the default is over the\n",
      "            last axis (i.e., ``axis=-1``).\n",
      "        overwrite_x : bool, optional\n",
      "            If True, the contents of `x` can be destroyed; the default is False.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        ifft : ndarray of floats\n",
      "            The inverse discrete Fourier transform.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        fft : Forward FFT\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Both single and double precision routines are implemented.  Half precision\n",
      "        inputs will be converted to single precision.  Non floating-point inputs\n",
      "        will be converted to double precision.  Long-double precision inputs are\n",
      "        not supported.\n",
      "        \n",
      "        This function is most efficient when `n` is a power of two, and least\n",
      "        efficient when `n` is prime.\n",
      "        \n",
      "        If the data type of `x` is real, a \"real IFFT\" algorithm is automatically\n",
      "        used, which roughly halves the computation time.\n",
      "    \n",
      "    ifft2(x, shape=None, axes=(-2, -1), overwrite_x=False)\n",
      "        2-D discrete inverse Fourier transform of real or complex sequence.\n",
      "        \n",
      "        Return inverse two-dimensional discrete Fourier transform of\n",
      "        arbitrary type sequence x.\n",
      "        \n",
      "        See `ifft` for more information.\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        fft2, ifft\n",
      "    \n",
      "    ifftn(x, shape=None, axes=None, overwrite_x=False)\n",
      "        Return inverse multi-dimensional discrete Fourier transform of\n",
      "        arbitrary type sequence x.\n",
      "        \n",
      "        The returned array contains::\n",
      "        \n",
      "          y[j_1,..,j_d] = 1/p * sum[k_1=0..n_1-1, ..., k_d=0..n_d-1]\n",
      "             x[k_1,..,k_d] * prod[i=1..d] exp(sqrt(-1)*2*pi/n_i * j_i * k_i)\n",
      "        \n",
      "        where ``d = len(x.shape)``, ``n = x.shape``, and ``p = prod[i=1..d] n_i``.\n",
      "        \n",
      "        For description of parameters see `fftn`.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        fftn : for detailed information.\n",
      "    \n",
      "    ifftshift(x, axes=None)\n",
      "        The inverse of `fftshift`. Although identical for even-length `x`, the\n",
      "        functions differ by one sample for odd-length `x`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            Input array.\n",
      "        axes : int or shape tuple, optional\n",
      "            Axes over which to calculate.  Defaults to None, which shifts all axes.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        y : ndarray\n",
      "            The shifted array.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        fftshift : Shift zero-frequency component to the center of the spectrum.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> freqs = np.fft.fftfreq(9, d=1./9).reshape(3, 3)\n",
      "        >>> freqs\n",
      "        array([[ 0.,  1.,  2.],\n",
      "               [ 3.,  4., -4.],\n",
      "               [-3., -2., -1.]])\n",
      "        >>> np.fft.ifftshift(np.fft.fftshift(freqs))\n",
      "        array([[ 0.,  1.,  2.],\n",
      "               [ 3.,  4., -4.],\n",
      "               [-3., -2., -1.]])\n",
      "    \n",
      "    ihilbert(x)\n",
      "        Return inverse Hilbert transform of a periodic sequence x.\n",
      "        \n",
      "        If ``x_j`` and ``y_j`` are Fourier coefficients of periodic functions x\n",
      "        and y, respectively, then::\n",
      "        \n",
      "          y_j = -sqrt(-1)*sign(j) * x_j\n",
      "          y_0 = 0\n",
      "    \n",
      "    irfft(x, n=None, axis=-1, overwrite_x=False)\n",
      "        Return inverse discrete Fourier transform of real sequence x.\n",
      "        \n",
      "        The contents of `x` are interpreted as the output of the `rfft`\n",
      "        function.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            Transformed data to invert.\n",
      "        n : int, optional\n",
      "            Length of the inverse Fourier transform.\n",
      "            If n < x.shape[axis], x is truncated.\n",
      "            If n > x.shape[axis], x is zero-padded.\n",
      "            The default results in n = x.shape[axis].\n",
      "        axis : int, optional\n",
      "            Axis along which the ifft's are computed; the default is over\n",
      "            the last axis (i.e., axis=-1).\n",
      "        overwrite_x : bool, optional\n",
      "            If True, the contents of `x` can be destroyed; the default is False.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        irfft : ndarray of floats\n",
      "            The inverse discrete Fourier transform.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        rfft, ifft\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The returned real array contains::\n",
      "        \n",
      "            [y(0),y(1),...,y(n-1)]\n",
      "        \n",
      "        where for n is even::\n",
      "        \n",
      "            y(j) = 1/n (sum[k=1..n/2-1] (x[2*k-1]+sqrt(-1)*x[2*k])\n",
      "                                         * exp(sqrt(-1)*j*k* 2*pi/n)\n",
      "                        + c.c. + x[0] + (-1)**(j) x[n-1])\n",
      "        \n",
      "        and for n is odd::\n",
      "        \n",
      "            y(j) = 1/n (sum[k=1..(n-1)/2] (x[2*k-1]+sqrt(-1)*x[2*k])\n",
      "                                         * exp(sqrt(-1)*j*k* 2*pi/n)\n",
      "                        + c.c. + x[0])\n",
      "        \n",
      "        c.c. denotes complex conjugate of preceding expression.\n",
      "        \n",
      "        For details on input parameters, see `rfft`.\n",
      "    \n",
      "    itilbert(x, h, period=None, _cache={})\n",
      "        Return inverse h-Tilbert transform of a periodic sequence x.\n",
      "        \n",
      "        If ``x_j`` and ``y_j`` are Fourier coefficients of periodic functions x\n",
      "        and y, respectively, then::\n",
      "        \n",
      "          y_j = -sqrt(-1)*tanh(j*h*2*pi/period) * x_j\n",
      "          y_0 = 0\n",
      "        \n",
      "        For more details, see `tilbert`.\n",
      "    \n",
      "    next_fast_len(target)\n",
      "        Find the next fast size of input data to `fft`, for zero-padding, etc.\n",
      "        \n",
      "        SciPy's FFTPACK has efficient functions for radix {2, 3, 4, 5}, so this\n",
      "        returns the next composite of the prime factors 2, 3, and 5 which is\n",
      "        greater than or equal to `target`. (These are also known as 5-smooth\n",
      "        numbers, regular numbers, or Hamming numbers.)\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        target : int\n",
      "            Length to start searching from.  Must be a positive integer.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : int\n",
      "            The first 5-smooth number greater than or equal to `target`.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        .. versionadded:: 0.18.0\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        On a particular machine, an FFT of prime length takes 133 ms:\n",
      "        \n",
      "        >>> from scipy import fftpack\n",
      "        >>> min_len = 10007  # prime length is worst case for speed\n",
      "        >>> a = np.random.randn(min_len)\n",
      "        >>> b = fftpack.fft(a)\n",
      "        \n",
      "        Zero-padding to the next 5-smooth length reduces computation time to\n",
      "        211 us, a speedup of 630 times:\n",
      "        \n",
      "        >>> fftpack.helper.next_fast_len(min_len)\n",
      "        10125\n",
      "        >>> b = fftpack.fft(a, 10125)\n",
      "        \n",
      "        Rounding up to the next power of 2 is not optimal, taking 367 us to\n",
      "        compute, 1.7 times as long as the 5-smooth size:\n",
      "        \n",
      "        >>> b = fftpack.fft(a, 16384)\n",
      "    \n",
      "    rfft(x, n=None, axis=-1, overwrite_x=False)\n",
      "        Discrete Fourier transform of a real sequence.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like, real-valued\n",
      "            The data to transform.\n",
      "        n : int, optional\n",
      "            Defines the length of the Fourier transform.  If `n` is not specified\n",
      "            (the default) then ``n = x.shape[axis]``.  If ``n < x.shape[axis]``,\n",
      "            `x` is truncated, if ``n > x.shape[axis]``, `x` is zero-padded.\n",
      "        axis : int, optional\n",
      "            The axis along which the transform is applied.  The default is the\n",
      "            last axis.\n",
      "        overwrite_x : bool, optional\n",
      "            If set to true, the contents of `x` can be overwritten. Default is\n",
      "            False.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        z : real ndarray\n",
      "            The returned real array contains::\n",
      "        \n",
      "              [y(0),Re(y(1)),Im(y(1)),...,Re(y(n/2))]              if n is even\n",
      "              [y(0),Re(y(1)),Im(y(1)),...,Re(y(n/2)),Im(y(n/2))]   if n is odd\n",
      "        \n",
      "            where::\n",
      "        \n",
      "              y(j) = sum[k=0..n-1] x[k] * exp(-sqrt(-1)*j*k*2*pi/n)\n",
      "              j = 0..n-1\n",
      "        \n",
      "            Note that ``y(-j) == y(n-j).conjugate()``.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        fft, irfft, scipy.fftpack.basic\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Within numerical accuracy, ``y == rfft(irfft(y))``.\n",
      "        \n",
      "        Both single and double precision routines are implemented.  Half precision\n",
      "        inputs will be converted to single precision.  Non floating-point inputs\n",
      "        will be converted to double precision.  Long-double precision inputs are\n",
      "        not supported.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> from scipy.fftpack import fft, rfft\n",
      "        >>> a = [9, -9, 1, 3]\n",
      "        >>> fft(a)\n",
      "        array([  4. +0.j,   8.+12.j,  16. +0.j,   8.-12.j])\n",
      "        >>> rfft(a)\n",
      "        array([  4.,   8.,  12.,  16.])\n",
      "    \n",
      "    rfftfreq(n, d=1.0)\n",
      "        DFT sample frequencies (for usage with rfft, irfft).\n",
      "        \n",
      "        The returned float array contains the frequency bins in\n",
      "        cycles/unit (with zero at the start) given a window length `n` and a\n",
      "        sample spacing `d`::\n",
      "        \n",
      "          f = [0,1,1,2,2,...,n/2-1,n/2-1,n/2]/(d*n)   if n is even\n",
      "          f = [0,1,1,2,2,...,n/2-1,n/2-1,n/2,n/2]/(d*n)   if n is odd\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        n : int\n",
      "            Window length.\n",
      "        d : scalar, optional\n",
      "            Sample spacing. Default is 1.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray\n",
      "            The array of length `n`, containing the sample frequencies.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> from scipy import fftpack\n",
      "        >>> sig = np.array([-2, 8, 6, 4, 1, 0, 3, 5], dtype=float)\n",
      "        >>> sig_fft = fftpack.rfft(sig)\n",
      "        >>> n = sig_fft.size\n",
      "        >>> timestep = 0.1\n",
      "        >>> freq = fftpack.rfftfreq(n, d=timestep)\n",
      "        >>> freq\n",
      "        array([ 0.  ,  1.25,  1.25,  2.5 ,  2.5 ,  3.75,  3.75,  5.  ])\n",
      "    \n",
      "    sc_diff(x, a, b, period=None, _cache={})\n",
      "        Return (a,b)-sinh/cosh pseudo-derivative of a periodic sequence x.\n",
      "        \n",
      "        If x_j and y_j are Fourier coefficients of periodic functions x\n",
      "        and y, respectively, then::\n",
      "        \n",
      "          y_j = sqrt(-1)*sinh(j*a*2*pi/period)/cosh(j*b*2*pi/period) * x_j\n",
      "          y_0 = 0\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            Input array.\n",
      "        a,b : float\n",
      "            Defines the parameters of the sinh/cosh pseudo-differential\n",
      "            operator.\n",
      "        period : float, optional\n",
      "            The period of the sequence x. Default is 2*pi.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        ``sc_diff(cs_diff(x,a,b),b,a) == x``\n",
      "        For even ``len(x)``, the Nyquist mode of x is taken as zero.\n",
      "    \n",
      "    shift(x, a, period=None, _cache={})\n",
      "        Shift periodic sequence x by a: y(u) = x(u+a).\n",
      "        \n",
      "        If x_j and y_j are Fourier coefficients of periodic functions x\n",
      "        and y, respectively, then::\n",
      "        \n",
      "              y_j = exp(j*a*2*pi/period*sqrt(-1)) * x_f\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            The array to take the pseudo-derivative from.\n",
      "        a : float\n",
      "            Defines the parameters of the sinh/sinh pseudo-differential\n",
      "        period : float, optional\n",
      "            The period of the sequences x and y. Default period is ``2*pi``.\n",
      "    \n",
      "    ss_diff(x, a, b, period=None, _cache={})\n",
      "        Return (a,b)-sinh/sinh pseudo-derivative of a periodic sequence x.\n",
      "        \n",
      "        If x_j and y_j are Fourier coefficients of periodic functions x\n",
      "        and y, respectively, then::\n",
      "        \n",
      "          y_j = sinh(j*a*2*pi/period)/sinh(j*b*2*pi/period) * x_j\n",
      "          y_0 = a/b * x_0\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            The array to take the pseudo-derivative from.\n",
      "        a,b\n",
      "            Defines the parameters of the sinh/sinh pseudo-differential\n",
      "            operator.\n",
      "        period : float, optional\n",
      "            The period of the sequence x. Default is ``2*pi``.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        ``ss_diff(ss_diff(x,a,b),b,a) == x``\n",
      "    \n",
      "    tilbert(x, h, period=None, _cache={})\n",
      "        Return h-Tilbert transform of a periodic sequence x.\n",
      "        \n",
      "        If x_j and y_j are Fourier coefficients of periodic functions x\n",
      "        and y, respectively, then::\n",
      "        \n",
      "            y_j = sqrt(-1)*coth(j*h*2*pi/period) * x_j\n",
      "            y_0 = 0\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            The input array to transform.\n",
      "        h : float\n",
      "            Defines the parameter of the Tilbert transform.\n",
      "        period : float, optional\n",
      "            The assumed period of the sequence.  Default period is ``2*pi``.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        tilbert : ndarray\n",
      "            The result of the transform.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        If ``sum(x, axis=0) == 0`` and ``n = len(x)`` is odd then\n",
      "        ``tilbert(itilbert(x)) == x``.\n",
      "        \n",
      "        If ``2 * pi * h / period`` is approximately 10 or larger, then\n",
      "        numerically ``tilbert == hilbert``\n",
      "        (theoretically oo-Tilbert == Hilbert).\n",
      "        \n",
      "        For even ``len(x)``, the Nyquist mode of ``x`` is taken zero.\n",
      "\n",
      "DATA\n",
      "    __all__ = ['fft', 'ifft', 'fftn', 'ifftn', 'rfft', 'irfft', 'fft2', 'i...\n",
      "\n",
      "VERSION\n",
      "    0.4.3\n",
      "\n",
      "FILE\n",
      "    /home/cmoman/anaconda3/envs/snowflakes/lib/python3.5/site-packages/scipy/fftpack/__init__.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(sp.fftpack)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "temp_psd = np.abs(temp_fft) ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "fftfreq = sp.fftpack.fftfreq(len(temp_psd),\n",
    "1./365)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "i= fftfreq>0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.text.Text at 0x7fb8c9ebd400>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEKCAYAAAAfGVI8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fb8c9f09be0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(fftfreq[i], 10*np.log10(temp_psd[i]))\n",
    "plt.xlim(0, 5)\n",
    "plt.xlabel('Frequency (1/year)')\n",
    "plt.ylabel('PSD (dB)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "temp_fft_bis = temp_fft.copy()\n",
    "temp_fft_bis[np.abs(fftfreq) > 1.1] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "temp_slow = np.real(sp.fftpack.ifft(temp_fft_bis))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.text.Text at 0x7fb8c9e7e860>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZQAAAEKCAYAAAA1qaOTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fb8c9eac198>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot_date(date, temp, '-', lw=.5)\n",
    "plt.plot_date(date, temp_slow, '-')\n",
    "plt.xlim(datetime.date(1994, 1, 1),\n",
    "datetime.date(2000, 1, 1))\n",
    "plt.ylim(-10, 40)\n",
    "plt.xlabel('Date')\n",
    "plt.ylabel('Mean temperature')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing fft/ifft..\n",
      "Success status:  True\n",
      "Testing in-place fft..\n",
      "Success status:  True\n"
     ]
    }
   ],
   "source": [
    "from __future__ import print_function\n",
    "\n",
    "import pycuda.autoinit\n",
    "import pycuda.gpuarray as gpuarray\n",
    "\n",
    "import skcuda.fft as cu_fft\n",
    "\n",
    "print('Testing fft/ifft..')\n",
    "N = 4096 * 16\n",
    "batch_size = 16\n",
    "\n",
    "x = np.asarray(np.random.rand(batch_size, N), np.float32)\n",
    "xf = np.fft.fft(x)\n",
    "y = np.real(np.fft.ifft(xf))\n",
    "\n",
    "x_gpu = gpuarray.to_gpu(x)\n",
    "xf_gpu = gpuarray.empty((batch_size, N//2+1), np.complex64)\n",
    "plan_forward = cu_fft.Plan(N, np.float32, np.complex64, batch_size)\n",
    "cu_fft.fft(x_gpu, xf_gpu, plan_forward)\n",
    "\n",
    "y_gpu = gpuarray.empty_like(x_gpu)\n",
    "plan_inverse = cu_fft.Plan(N, np.complex64, np.float32, batch_size)\n",
    "cu_fft.ifft(xf_gpu, y_gpu, plan_inverse, True)\n",
    "\n",
    "print('Success status: ', np.allclose(y, y_gpu.get(), atol=1e-6))\n",
    "\n",
    "print('Testing in-place fft..')\n",
    "x = np.asarray(np.random.rand(batch_size, N) +\n",
    "               1j * np.random.rand(batch_size, N), np.complex64)\n",
    "x_gpu = gpuarray.to_gpu(x)\n",
    "\n",
    "plan = cu_fft.Plan(N, np.complex64, np.complex64, batch_size)\n",
    "cu_fft.fft(x_gpu, x_gpu, plan)\n",
    "\n",
    "cu_fft.ifft(x_gpu, x_gpu, plan, True)\n",
    "\n",
    "print('Success status: ', np.allclose(x, x_gpu.get(), atol=1e-6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "pandas.core.series.Series"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(temp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(temp_fft)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'col' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-24-5484df5cd031>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtemp\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcol\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'col' is not defined"
     ]
    }
   ],
   "source": [
    "temp[col]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'h1' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-25-ebf87910a640>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mh1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'h1' is not defined"
     ]
    }
   ],
   "source": [
    "h1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "t_gpu = gpuarray.to_gpu(temp2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": [
    "tf_gpu = gpuarray.empty((batch_size, N//2+1), np.complex64)\n",
    "plan_forward = cu_fft.Plan(N, np.float32, np.complex64, batch_size)\n",
    "cu_fft.fft(t_gpu, tf_gpu, plan_forward)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "ename": "LogicError",
     "evalue": "cuMemcpyDtoH failed: an illegal memory access was encountered",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mLogicError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-28-a2518b3def11>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtf_gpu\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/home/cmoman/anaconda3/envs/snowflakes/lib/python3.5/site-packages/pycuda-2016.1.2-py3.5-linux-x86_64.egg/pycuda/gpuarray.py\u001b[0m in \u001b[0;36mget\u001b[0;34m(self, ary, pagelocked, async, stream)\u001b[0m\n\u001b[1;32m    269\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    270\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 271\u001b[0;31m             \u001b[0m_memcpy_discontig\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mary\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0masync\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0masync\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstream\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstream\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    272\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mary\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    273\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/home/cmoman/anaconda3/envs/snowflakes/lib/python3.5/site-packages/pycuda-2016.1.2-py3.5-linux-x86_64.egg/pycuda/gpuarray.py\u001b[0m in \u001b[0;36m_memcpy_discontig\u001b[0;34m(dst, src, async, stream)\u001b[0m\n\u001b[1;32m   1188\u001b[0m                     \u001b[0mdrv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmemcpy_dtoh_async\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdst\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msrc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgpudata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstream\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstream\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1189\u001b[0m                 \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1190\u001b[0;31m                     \u001b[0mdrv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmemcpy_dtoh\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdst\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msrc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgpudata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1191\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1192\u001b[0m             \u001b[0msrc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_as_strided\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msrc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mshape\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msrc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstrides\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msrc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitemsize\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mLogicError\u001b[0m: cuMemcpyDtoH failed: an illegal memory access was encountered"
     ]
    }
   ],
   "source": [
    "tf_gpu.get()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "deletable": true,
    "editable": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}