Topic 07 - Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Index<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Introduction\" data-toc-modified-id=\"Introduction-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Introduction</a></span></li><li><span><a href=\"#Usage\" data-toc-modified-id=\"Usage-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Usage</a></span><ul class=\"toc-item\"><li><span><a href=\"#linspace\" data-toc-modified-id=\"linspace-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span><em>linspace</em></a></span></li><li><span><a href=\"#Min-and-Max\" data-toc-modified-id=\"Min-and-Max-2.2\"><span class=\"toc-item-num\">2.2&nbsp;&nbsp;</span>Min and Max</a></span></li><li><span><a href=\"#Other-functions\" data-toc-modified-id=\"Other-functions-2.3\"><span class=\"toc-item-num\">2.3&nbsp;&nbsp;</span>Other functions</a></span></li><li><span><a href=\"#Creating-arrays-by-using-lists\" data-toc-modified-id=\"Creating-arrays-by-using-lists-2.4\"><span class=\"toc-item-num\">2.4&nbsp;&nbsp;</span>Creating arrays by using lists</a></span></li><li><span><a href=\"#Accessing-and-changing-elements\" data-toc-modified-id=\"Accessing-and-changing-elements-2.5\"><span class=\"toc-item-num\">2.5&nbsp;&nbsp;</span>Accessing and changing elements</a></span></li><li><span><a href=\"#random\" data-toc-modified-id=\"random-2.6\"><span class=\"toc-item-num\">2.6&nbsp;&nbsp;</span><em>random</em></a></span></li><li><span><a href=\"#Constants\" data-toc-modified-id=\"Constants-2.7\"><span class=\"toc-item-num\">2.7&nbsp;&nbsp;</span>Constants</a></span></li><li><span><a href=\"#Arrays-multiplication\" data-toc-modified-id=\"Arrays-multiplication-2.8\"><span class=\"toc-item-num\">2.8&nbsp;&nbsp;</span>Arrays multiplication</a></span></li></ul></li><li><span><a href=\"#Exercise\" data-toc-modified-id=\"Exercise-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Exercise</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "\n",
    "Numpy is a package for high efficiency numerical operations. A huge part of Python's scientific packages are built on numpy. Instead of using lists with numbers and for loops to operate on those lists, you can use *numpy arrays* to do the same more easily, and faster. Numpy is the package most similar to Matlab programming.\n",
    "\n",
    "# Usage\n",
    "\n",
    "It is common to import numpy and abbreviate it as **np**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you need to find something in numpy you can use the function **lookfor**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Search results for 'sin'\n",
      "------------------------\n",
      "numpy.sin\n",
      "    Trigonometric sine, element-wise.\n",
      "numpy.sinc\n",
      "    Return the sinc function.\n",
      "numpy.sinh\n",
      "    Hyperbolic sine, element-wise.\n",
      "numpy.isinf\n",
      "    Test element-wise for positive or negative infinity.\n",
      "numpy.arcsin\n",
      "    Inverse sine, element-wise.\n",
      "numpy.arcsinh\n",
      "    Inverse hyperbolic sine element-wise.\n",
      "numpy.any\n",
      "    Test whether any array element along a given axis evaluates to True.\n",
      "numpy.cos\n",
      "    Cosine element-wise.\n",
      "numpy.cosh\n",
      "    Hyperbolic cosine, element-wise.\n",
      "numpy.savez\n",
      "    Save several arrays into a single file in uncompressed ``.npz`` format.\n",
      "numpy.trapz\n",
      "    Integrate along the given axis using the composite trapezoidal rule.\n",
      "numpy.MachAr\n",
      "    Diagnosing machine parameters.\n",
      "numpy.arccos\n",
      "    Trigonometric inverse cosine, element-wise.\n",
      "numpy.ma.sin\n",
      "    Trigonometric sine, element-wise.\n",
      "numpy.kaiser\n",
      "    Return the Kaiser window.\n",
      "numpy.memmap\n",
      "    Create a memory-map to an array stored in a *binary* file on disk.\n",
      "numpy.nditer\n",
      "    Efficient multi-dimensional iterator object to iterate over arrays.\n",
      "numpy.arccosh\n",
      "    Inverse hyperbolic cosine, element-wise.\n",
      "numpy.arctan2\n",
      "    Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly.\n",
      "numpy.argsort\n",
      "    Returns the indices that would sort an array.\n",
      "numpy.ma.sinh\n",
      "    Hyperbolic sine, element-wise.\n",
      "numpy.hamming\n",
      "    Return the Hamming window.\n",
      "numpy.hanning\n",
      "    Return the Hanning window.\n",
      "numpy.lexsort\n",
      "    Perform an indirect sort using a sequence of keys.\n",
      "numpy.squeeze\n",
      "    Remove single-dimensional entries from the shape of an array.\n",
      "numpy.blackman\n",
      "    Return the Blackman window.\n",
      "numpy.convolve\n",
      "    Returns the discrete, linear convolution of two one-dimensional sequences.\n",
      "numpy.gradient\n",
      "    Return the gradient of an N-dimensional array.\n",
      "numpy.recarray\n",
      "    Construct an ndarray that allows field access using attributes.\n",
      "numpy.ma.arcsin\n",
      "    Inverse sine, element-wise.\n",
      "numpy.array_str\n",
      "    Return a string representation of the data in an array.\n",
      "numpy.fromregex\n",
      "    Construct an array from a text file, using regular expression parsing.\n",
      "numpy.ndfromtxt\n",
      "    Load ASCII data stored in a file and return it as a single array.\n",
      "numpy.ma.arcsinh\n",
      "    Inverse hyperbolic sine element-wise.\n",
      "numpy.row_stack\n",
      "    Stack arrays in sequence vertically (row wise).\n",
      "numpy.genfromtxt\n",
      "    Load data from a text file, with missing values handled as specified.\n",
      "numpy.ma.cos\n",
      "    Cosine element-wise.\n",
      "numpy.ma.cov\n",
      "    Estimate the covariance matrix.\n",
      "numpy.argpartition\n",
      "    Perform an indirect partition along the given axis using the\n",
      "numpy.ma.cosh\n",
      "    Hyperbolic cosine, element-wise.\n",
      "numpy.sort_complex\n",
      "    Sort a complex array using the real part first, then the imaginary part.\n",
      "numpy.busdaycalendar\n",
      "    A business day calendar object that efficiently stores information\n",
      "numpy.ma.arccos\n",
      "    Trigonometric inverse cosine, element-wise.\n",
      "numpy.linalg.svd\n",
      "    Singular Value Decomposition.\n",
      "numpy.ma.arccosh\n",
      "    Inverse hyperbolic cosine, element-wise.\n",
      "numpy.ma.arctan2\n",
      "    Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly.\n",
      "numpy.bytes0.split\n",
      "    Return a list of the sections in the bytes, using sep as the delimiter.\n",
      "numpy.linalg.cond\n",
      "    Compute the condition number of a matrix.\n",
      "numpy.linalg.pinv\n",
      "    Compute the (Moore-Penrose) pseudo-inverse of a matrix.\n",
      "numpy.bytes0.decode\n",
      "    Decode the bytes using the codec registered for encoding.\n",
      "numpy.ma.allequal\n",
      "    Return True if all entries of a and b are equal, using\n",
      "numpy.bytes0.rsplit\n",
      "    Return a list of the sections in the bytes, using sep as the delimiter.\n",
      "numpy.savez_compressed\n",
      "    Save several arrays into a single file in compressed ``.npz`` format.\n",
      "numpy.str0.split\n",
      "    Return a list of the words in S, using sep as the\n",
      "numpy.ma.corrcoef\n",
      "    Return Pearson product-moment correlation coefficients.\n",
      "numpy.f2py.compile\n",
      "    Build extension module from processing source with f2py.\n",
      "numpy.str0.encode\n",
      "    Encode S using the codec registered for encoding. Default encoding\n",
      "numpy.str0.format\n",
      "    Return a formatted version of S, using substitutions from args and kwargs.\n",
      "numpy.str0.rsplit\n",
      "    Return a list of the words in S, using sep as the\n",
      "numpy.f2py.run_main\n",
      "    In case of using -h flag, return None.\n",
      "numpy.testing.test\n",
      "    Run tests for module using nose.\n",
      "numpy.chararray.split\n",
      "    For each element in `self`, return a list of the words in the\n",
      "numpy.bytes0.partition\n",
      "    Partition the bytes into three parts using the given separator.\n",
      "numpy.chararray.rsplit\n",
      "    For each element in `self`, return a list of the words in\n",
      "numpy.matrix.flatten\n",
      "    Return a flattened copy of the matrix.\n",
      "numpy.bytes0.expandtabs\n",
      "    Return a copy of B where all tab characters are expanded using spaces.\n",
      "numpy.bytes0.rpartition\n",
      "    Partition the bytes into three parts using the given separator.\n",
      "numpy.ufunc.reduceat\n",
      "    Performs a (local) reduce with specified slices over a single axis.\n",
      "numpy.chararray.squeeze\n",
      "    Remove single-dimensional entries from the shape of `a`.\n",
      "numpy.nditer.iternext\n",
      "    iternext()\n",
      "numpy.linalg.multi_dot\n",
      "    Compute the dot product of two or more arrays in a single function call,\n",
      "numpy.str0.expandtabs\n",
      "    Return a copy of S where all tab characters are expanded using spaces.\n",
      "numpy.str0.format_map\n",
      "    S.format_map(mapping) -> str\n",
      "numpy.ma.masked_values\n",
      "    Mask using floating point equality.\n",
      "numpy.matrix._collapse\n",
      "    A convenience function for operations that want to collapse\n",
      "numpy.linalg.matrix_rank\n",
      "    Return matrix rank of array using SVD method\n",
      "numpy.distutils.FormatError\n",
      "    Exception thrown when there is a problem parsing a configuration file.\n",
      "numpy.ctypeslib.load_library\n",
      "    It is possible to load a library using\n",
      "numpy.testing.Tester.test\n",
      "    Run tests for module using nose.\n",
      "numpy.testing.Tester.bench\n",
      "    Run benchmarks for module using nose.\n",
      "numpy.ma.MaskedArray.squeeze\n",
      "    Remove single-dimensional entries from the shape of `a`.\n",
      "numpy.ma.MaskedArray.compress\n",
      "    Return `a` where condition is ``True``.\n",
      "numpy.distutils.misc_util.njoin\n",
      "    Join two or more pathname components +\n",
      "numpy.distutils.misc_util.allpath\n",
      "    Convert a /-separated pathname to one using the OS's path separator.\n",
      "numpy.distutils.misc_util.mingw32\n",
      "    Return true when using mingw32 environment.\n",
      "numpy.lib._iotools.flatten_dtype\n",
      "    Unpack a structured data-type by collapsing nested fields and/or fields\n",
      "numpy.core.multiarray.set_typeDict\n",
      "    set_typeDict(dict)\n",
      "numpy.linalg._umath_linalg.eigh_lo\n",
      "    eigh on the last two dimension and broadcast to the rest, using lower triangle\n",
      "numpy.linalg._umath_linalg.eigh_up\n",
      "    eigh on the last two dimension and broadcast to the rest, using upper triangle.\n",
      "numpy.i0\n",
      "    Modified Bessel function of the first kind, order 0.\n",
      "numpy.isposinf\n",
      "    Test element-wise for positive infinity, return result as bool array.\n",
      "numpy.all\n",
      "    Test whether all array elements along a given axis evaluate to True.\n",
      "numpy.cov\n",
      "    Estimate a covariance matrix, given data and weights.\n",
      "numpy.exp\n",
      "    Calculate the exponential of all elements in the input array.\n",
      "numpy.irr\n",
      "    Return the Internal Rate of Return (IRR).\n",
      "numpy.ix_\n",
      "    Construct an open mesh from multiple sequences.\n",
      "numpy.pad\n",
      "    Pads an array.\n",
      "numpy.lib.format.read_array_header_1_0\n",
      "    Read an array header from a filelike object using the 1.0 file format\n",
      "numpy.lib.format.read_array_header_2_0\n",
      "    Read an array header from a filelike object using the 2.0 file format\n",
      "numpy.linalg._umath_linalg.eigvalsh_lo\n",
      "    eigh on the last two dimension and broadcast to the rest, using lower triangle.\n",
      "numpy.linalg._umath_linalg.eigvalsh_up\n",
      "    eigvalsh on the last two dimension and broadcast to the rest, using upper triangle.\n",
      "numpy.std\n",
      "    Compute the standard deviation along the specified axis.\n",
      "numpy.sum\n",
      "    Sum of array elements over a given axis.\n",
      "numpy.tan\n",
      "    Compute tangent element-wise.\n",
      "numpy.var\n",
      "    Compute the variance along the specified axis.\n",
      "numpy.amax\n",
      "    Return the maximum of an array or maximum along an axis.\n",
      "numpy.amin\n",
      "    Return the minimum of an array or minimum along an axis.\n",
      "numpy.diag\n",
      "    Extract a diagonal or construct a diagonal array.\n",
      "numpy.diff\n",
      "    Calculate the n-th discrete difference along given axis.\n",
      "numpy.flip\n",
      "    Reverse the order of elements in an array along the given axis.\n",
      "numpy.info\n",
      "    Get help information for a function, class, or module.\n",
      "numpy.less\n",
      "    Return the truth value of (x1 < x2) element-wise.\n",
      "numpy.load\n",
      "    Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files.\n",
      "numpy.mean\n",
      "    Compute the arithmetic mean along the specified axis.\n",
      "numpy.prod\n",
      "    Return the product of array elements over a given axis.\n",
      "numpy.lib.format.write_array_header_1_0\n",
      "    Write the header for an array using the 1.0 format.\n",
      "numpy.lib.format.write_array_header_2_0\n",
      "    Write the header for an array using the 2.0 format.\n",
      "numpy.save\n",
      "    Save an array to a binary file in NumPy ``.npy`` format.\n",
      "numpy.sort\n",
      "    Return a sorted copy of an array.\n",
      "numpy.str0\n",
      "    str(bytes_or_buffer[, encoding[, errors]]) -> str\n",
      "numpy.take\n",
      "    Take elements from an array along an axis.\n",
      "numpy.tanh\n",
      "    Compute hyperbolic tangent element-wise.\n",
      "numpy.testing.Tester.prepare_test_args\n",
      "    Run tests for module using nose.\n",
      "numpy.vdot\n",
      "    Return the dot product of two vectors.\n",
      "numpy.array\n",
      "    Create an array.\n",
      "numpy.testing.suppress_warnings.filter\n",
      "    Add a new suppressing filter or apply it if the state is entered.\n",
      "numpy.cross\n",
      "    Return the cross product of two (arrays of) vectors.\n",
      "numpy.dtype\n",
      "    Create a data type object.\n",
      "numpy.equal\n",
      "    Return (x1 == x2) element-wise.\n",
      "numpy.inner\n",
      "    Inner product of two arrays.\n",
      "numpy.isnan\n",
      "    Test element-wise for NaN and return result as a boolean array.\n",
      "numpy.outer\n",
      "    Compute the outer product of two vectors.\n",
      "numpy.ravel\n",
      "    Return a contiguous flattened array.\n",
      "numpy.ufunc\n",
      "    Functions that operate element by element on whole arrays.\n",
      "numpy.arange\n",
      "    Return evenly spaced values within a given interval.\n",
      "numpy.around\n",
      "    Evenly round to the given number of decimals.\n",
      "numpy.bytes0\n",
      "    bytes(iterable_of_ints) -> bytes\n",
      "numpy.choose\n",
      "    Construct an array from an index array and a set of arrays to choose from.\n",
      "numpy.cumsum\n",
      "    Return the cumulative sum of the elements along a given axis.\n",
      "numpy.dstack\n",
      "    Stack arrays in sequence depth wise (along third axis).\n",
      "numpy.einsum\n",
      "    einsum(subscripts, *operands, out=None, dtype=None, order='K',\n",
      "numpy.fliplr\n",
      "    Flip array in the left/right direction.\n",
      "numpy.flipud\n",
      "    Flip array in the up/down direction.\n",
      "numpy.hstack\n",
      "    Stack arrays in sequence horizontally (column wise).\n",
      "numpy.insert\n",
      "    Insert values along the given axis before the given indices.\n",
      "numpy.interp\n",
      "    One-dimensional linear interpolation.\n",
      "numpy.median\n",
      "    Compute the median along the specified axis.\n",
      "numpy.nanstd\n",
      "    Compute the standard deviation along the specified axis, while\n",
      "numpy.nanvar\n",
      "    Compute the variance along the specified axis, while ignoring NaNs.\n",
      "numpy.poly1d\n",
      "    A one-dimensional polynomial class.\n",
      "numpy.seterr\n",
      "    Set how floating-point errors are handled.\n",
      "numpy.source\n",
      "    Print or write to a file the source code for a NumPy object.\n",
      "numpy.vander\n",
      "    Generate a Vandermonde matrix.\n",
      "numpy.average\n",
      "    Compute the weighted average along the specified axis.\n",
      "numpy.cumprod\n",
      "    Return the cumulative product of elements along a given axis.\n",
      "numpy.greater\n",
      "    Return the truth value of (x1 > x2) element-wise.\n",
      "numpy.isclose\n",
      "    Returns a boolean array where two arrays are element-wise equal within a\n",
      "numpy.loadtxt\n",
      "    Load data from a text file.\n",
      "numpy.maximum\n",
      "    Element-wise maximum of array elements.\n",
      "numpy.minimum\n",
      "    Element-wise minimum of array elements.\n",
      "numpy.nanmean\n",
      "    Compute the arithmetic mean along the specified axis, ignoring NaNs.\n",
      "numpy.ndarray\n",
      "    ndarray(shape, dtype=float, buffer=None, offset=0,\n",
      "numpy.nonzero\n",
      "    Return the indices of the elements that are non-zero.\n",
      "numpy.polyadd\n",
      "    Find the sum of two polynomials.\n",
      "numpy.polyfit\n",
      "    Least squares polynomial fit.\n",
      "numpy.polyint\n",
      "    Return an antiderivative (indefinite integral) of a polynomial.\n",
      "numpy.polymul\n",
      "    Find the product of two polynomials.\n",
      "numpy.require\n",
      "    Return an ndarray of the provided type that satisfies requirements.\n",
      "numpy.reshape\n",
      "    Gives a new shape to an array without changing its data.\n",
      "numpy.savetxt\n",
      "    Save an array to a text file.\n",
      "numpy.bartlett\n",
      "    Return the Bartlett window.\n",
      "numpy.bincount\n",
      "    Count number of occurrences of each value in array of non-negative ints.\n",
      "numpy.can_cast\n",
      "    Returns True if cast between data types can occur according to the\n",
      "numpy.corrcoef\n",
      "    Return Pearson product-moment correlation coefficients.\n",
      "numpy.digitize\n",
      "    Return the indices of the bins to which each value in input array belongs.\n",
      "numpy.errstate\n",
      "    errstate(**kwargs)\n",
      "numpy.flatiter\n",
      "    Flat iterator object to iterate over arrays.\n",
      "numpy.fromfile\n",
      "    Construct an array from data in a text or binary file.\n",
      "numpy.isfinite\n",
      "    Test element-wise for finiteness (not infinity or not Not a Number).\n",
      "numpy.isneginf\n",
      "    Test element-wise for negative infinity, return result as bool array.\n",
      "numpy.meshgrid\n",
      "    Return coordinate matrices from coordinate vectors.\n",
      "numpy.typename\n",
      "    Return a description for the given data type code.\n",
      "numpy.testing.Tester._get_custom_doctester\n",
      "    Return instantiated plugin for doctests\n",
      "numpy.broadcast\n",
      "    Produce an object that mimics broadcasting.\n",
      "numpy.chararray\n",
      "    chararray(shape, itemsize=1, unicode=False, buffer=None, offset=0,\n",
      "numpy.correlate\n",
      "    Cross-correlation of two 1-dimensional sequences.\n",
      "numpy.geomspace\n",
      "    Return numbers spaced evenly on a log scale (a geometric progression).\n",
      "numpy.geterrobj\n",
      "    geterrobj()\n",
      "numpy.histogram\n",
      "    Compute the histogram of a set of data.\n",
      "numpy.nanargmax\n",
      "    Return the indices of the maximum values in the specified axis ignoring\n",
      "numpy.nanargmin\n",
      "    Return the indices of the minimum values in the specified axis ignoring\n",
      "numpy.nanmedian\n",
      "    Compute the median along the specified axis, while ignoring NaNs.\n",
      "numpy.partition\n",
      "    Return a partitioned copy of an array.\n",
      "numpy.seterrobj\n",
      "    seterrobj(errobj)\n",
      "numpy.tensordot\n",
      "    Compute tensor dot product along specified axes for arrays >= 1-D.\n",
      "numpy.transpose\n",
      "    Permute the dimensions of an array.\n",
      "numpy.vectorize\n",
      "    vectorize(pyfunc, otypes=None, doc=None, excluded=None, cache=False,\n",
      "numpy.array_repr\n",
      "    Return the string representation of an array.\n",
      "numpy.frompyfunc\n",
      "    Takes an arbitrary Python function and returns a NumPy ufunc.\n",
      "numpy.left_shift\n",
      "    Shift the bits of an integer to the left.\n",
      "numpy.less_equal\n",
      "    Return the truth value of (x1 =< x2) element-wise.\n",
      "numpy.nan_to_num\n",
      "    Replace nan with zero and inf with finite numbers.\n",
      "numpy.percentile\n",
      "    Compute the qth percentile of the data along the specified axis.\n",
      "numpy.seterrcall\n",
      "    Set the floating-point error callback function or log object.\n",
      "numpy.binary_repr\n",
      "    Return the binary representation of the input number as a string.\n",
      "numpy.bitwise_not\n",
      "    Compute bit-wise inversion, or bit-wise NOT, element-wise.\n",
      "numpy.einsum_path\n",
      "    Evaluates the lowest cost contraction order for an einsum expression by\n",
      "numpy.get_include\n",
      "    Return the directory that contains the NumPy \\*.h header files.\n",
      "numpy.issubclass_\n",
      "    Determine if a class is a subclass of a second class.\n",
      "numpy.fft.fft\n",
      "    Compute the one-dimensional discrete Fourier Transform.\n",
      "numpy.ma.exp\n",
      "    Calculate the exponential of all elements in the input array.\n",
      "numpy.array2string\n",
      "    Return a string representation of an array.\n",
      "numpy.ma.tan\n",
      "    Compute tangent element-wise.\n",
      "numpy.ma.var\n",
      "    Compute the variance along the specified axis.\n",
      "numpy.broadcast_to\n",
      "    Broadcast an array to a new shape.\n",
      "numpy.column_stack\n",
      "    Stack 1-D arrays as columns into a 2-D array.\n",
      "numpy.fft.fft2\n",
      "    Compute the 2-dimensional discrete Fourier Transform\n",
      "numpy.fft.fftn\n",
      "    Compute the N-dimensional discrete Fourier Transform.\n",
      "numpy.fft.ifft\n",
      "    Compute the one-dimensional inverse discrete Fourier Transform.\n",
      "numpy.distutils.ccompiler.CCompiler_customize_cmd\n",
      "    Customize compiler using distutils command.\n",
      "numpy.ma.less\n",
      "    Return the truth value of (x1 < x2) element-wise.\n",
      "numpy.ma.prod\n",
      "    Return the product of the array elements over the given axis.\n",
      "numpy.ma.sort\n",
      "    Sort the array, in-place\n",
      "numpy.ma.tanh\n",
      "    Compute hyperbolic tangent element-wise.\n",
      "numpy.busday_offset\n",
      "    First adjusts the date to fall on a valid day according to\n",
      "numpy.greater_equal\n",
      "    Return the truth value of (x1 >= x2) element-wise.\n",
      "numpy.nanpercentile\n",
      "    Compute the qth percentile of the data along the specified axis,\n",
      "numpy.ma.count\n",
      "    Count the non-masked elements of the array along the given axis.\n",
      "numpy.ma.equal\n",
      "    Return (x1 == x2) element-wise.\n",
      "numpy.fft.ifft2\n",
      "    Compute the 2-dimensional inverse discrete Fourier Transform.\n",
      "numpy.fft.ifftn\n",
      "    Compute the N-dimensional inverse discrete Fourier Transform.\n",
      "numpy.fft.irfft\n",
      "    Compute the inverse of the n-point DFT for real input.\n",
      "numpy.ma.inner\n",
      "    Inner product of two arrays.\n",
      "numpy.ma.outer\n",
      "    Compute the outer product of two vectors.\n",
      "numpy.ma.ravel\n",
      "    Returns a 1D version of self, as a view.\n",
      "numpy.linalg.qr\n",
      "    Compute the qr factorization of a matrix.\n",
      "numpy.ma.arange\n",
      "    Return evenly spaced values within a given interval.\n",
      "numpy.ma.cumsum\n",
      "    Return the cumulative sum of the array elements over the given axis.\n",
      "numpy.ma.dstack\n",
      "    dstack(tup)\n",
      "numpy.ma.hstack\n",
      "    hstack(tup)\n",
      "numpy.apply_over_axes\n",
      "    Apply a function repeatedly over multiple axes.\n",
      "numpy.ma.vander\n",
      "    Generate a Vandermonde matrix.\n",
      "numpy.distutils.fcompiler.FCompiler.preprocess\n",
      "    Preprocess a single C/C++ source file, named in 'source'.\n",
      "numpy.linalg.det\n",
      "    Compute the determinant of an array.\n",
      "numpy.linalg.eig\n",
      "    Compute the eigenvalues and right eigenvectors of a square array.\n",
      "numpy.bytes0.ljust\n",
      "    Return B left justified in a string of length width. Padding is\n",
      "numpy.bytes0.rjust\n",
      "    Return B right justified in a string of length width. Padding is\n",
      "numpy.ma.cumprod\n",
      "    Return the cumulative product of the array elements over the given axis.\n",
      "numpy.ma.greater\n",
      "    Return the truth value of (x1 > x2) element-wise.\n",
      "numpy.add_newdoc_ufunc\n",
      "    Replace the docstring for a ufunc with new_docstring.\n",
      "numpy.ma.nonzero\n",
      "    nonzero(self)\n",
      "numpy.ma.polyfit\n",
      "    Least squares polynomial fit.\n",
      "numpy.ma.product\n",
      "    Return the product of the array elements over the given axis.\n",
      "numpy.ma.putmask\n",
      "    Changes elements of an array based on conditional and input values.\n",
      "numpy.broadcast_arrays\n",
      "    Broadcast any number of arrays against each other.\n",
      "numpy.matrix.any\n",
      "    Test whether any array element along a given axis evaluates to True.\n",
      "numpy.distutils.unixccompiler.UnixCCompiler__compile\n",
      "    Compile a single source files with a Unix-style compiler.\n",
      "numpy.linalg.eigh\n",
      "    Return the eigenvalues and eigenvectors of a Hermitian or symmetric matrix.\n",
      "numpy.linalg.norm\n",
      "    Matrix or vector norm.\n",
      "numpy.bytes0.center\n",
      "    Return B centered in a string of length width.  Padding is\n",
      "numpy.str0.ljust\n",
      "    Return S left-justified in a Unicode string of length width. Padding is\n",
      "numpy.str0.rjust\n",
      "    Return S right-justified in a string of length width. Padding is\n",
      "numpy.ma.compress\n",
      "    Return `a` where condition is ``True``.\n",
      "numpy.set_printoptions\n",
      "    Set printing options.\n",
      "numpy.matlib.ones\n",
      "    Matrix of ones.\n",
      "numpy.matrix.getI\n",
      "    Returns the (multiplicative) inverse of invertible `self`.\n",
      "numpy.linalg.lstsq\n",
      "    Return the least-squares solution to a linear matrix equation.\n",
      "numpy.linalg.solve\n",
      "    Solve a linear matrix equation, or system of linear scalar equations.\n",
      "numpy.str0.center\n",
      "    Return S centered in a string of length width. Padding is\n",
      "numpy.ma.make_mask\n",
      "    Create a boolean mask from an array.\n",
      "numpy.ma.row_stack\n",
      "    vstack(tup)\n",
      "numpy.chararray.item\n",
      "    a.item(*args)\n",
      "numpy.matlib.zeros\n",
      "    Return a matrix of given shape and type, filled with zeros.\n",
      "numpy.chararray.sort\n",
      "    Sort an array, in-place.\n",
      "numpy.matrix.ravel\n",
      "    Return a flattened matrix.\n",
      "numpy.chararray.view\n",
      "    New view of array with the same data.\n",
      "numpy.ma.less_equal\n",
      "    Return the truth value of (x1 =< x2) element-wise.\n",
      "numpy.ufunc.reduce\n",
      "    Reduces `a`'s dimension by one, by applying ufunc along one axis.\n",
      "numpy.linalg.eigvals\n",
      "    Compute the eigenvalues of a general matrix.\n",
      "numpy.testing.noseclasses.NumpyDocTestCase.setUp\n",
      "    Hook method for setting up the test fixture before exercising it.\n",
      "numpy.linalg.slogdet\n",
      "    Compute the sign and (natural) logarithm of the determinant of an array.\n",
      "numpy.set_string_function\n",
      "    Set a Python function to be used when pretty printing arrays.\n",
      "numpy.ma.expand_dims\n",
      "    Expand the shape of an array.\n",
      "numpy.chararray.resize\n",
      "    Change shape and size of array in-place.\n",
      "numpy.chararray.tofile\n",
      "    Write array to a file as text or binary (default).\n",
      "numpy.matrix.squeeze\n",
      "    Return a possibly reshaped matrix.\n",
      "numpy.linalg.eigvalsh\n",
      "    Compute the eigenvalues of a Hermitian or real symmetric matrix.\n",
      "numpy.testing.noseclasses.NumpyDoctest.suiteClass\n",
      "    Doctest suites are parallelizable at the module or file level only,\n",
      "numpy.ma.column_stack\n",
      "    column_stack(tup)\n",
      "numpy.ma.mask_rowcols\n",
      "    Mask rows and/or columns of a 2D array that contain masked values.\n",
      "numpy.ma.masked_equal\n",
      "    Mask an array where equal to a given value.\n",
      "numpy.ma.masked_where\n",
      "    Mask an array where a condition is met.\n",
      "numpy.DataSource.abspath\n",
      "    Return absolute path of file in the DataSource directory.\n",
      "numpy.chararray.itemset\n",
      "    a.itemset(*args)\n",
      "numpy.linalg.tensorinv\n",
      "    Compute the 'inverse' of an N-dimensional array.\n",
      "numpy.testing.measure\n",
      "    Return elapsed time for executing code in the namespace of the caller.\n",
      "numpy.ma.greater_equal\n",
      "    Return the truth value of (x1 >= x2) element-wise.\n",
      "numpy.ma.masked_object\n",
      "    Mask the array `x` where the data are exactly equal to value.\n",
      "numpy.chararray.getfield\n",
      "    Returns a field of the given array as a certain type.\n",
      "numpy.chararray.setflags\n",
      "    Set array flags WRITEABLE, ALIGNED, and UPDATEIFCOPY, respectively.\n",
      "numpy.matrix.partition\n",
      "    Rearranges the elements in the array in such a way that value of the\n",
      "numpy.distutils.system_info.Numeric_info._check_libs\n",
      "    Find mandatory and optional libs in expected paths.\n",
      "numpy.ctypeslib.ndpointer\n",
      "    Array-checking restype/argtypes.\n",
      "numpy.distutils.command.sdist.sdist.read_template\n",
      "    Read and parse manifest template file named by self.template.\n",
      "numpy.linalg.LinAlgError\n",
      "    Generic Python-exception-derived object raised by linalg functions.\n",
      "numpy.linalg.tensorsolve\n",
      "    Solve the tensor equation ``a x = b`` for x.\n",
      "numpy.polynomial.Hermite\n",
      "    An Hermite series class.\n",
      "numpy.polynomial.HermiteE\n",
      "    An HermiteE series class.\n",
      "numpy.polynomial.Laguerre\n",
      "    A Laguerre series class.\n",
      "numpy.polynomial.Legendre\n",
      "    A Legendre series class.\n",
      "numpy.distutils.parse_flags\n",
      "    Parse a line from a config file containing compile flags.\n",
      "numpy.testing.noseclasses.NumpyTestProgram.createTests\n",
      "    Create the tests to run. If a self.suite\n",
      "numpy.distutils.intelccompiler.IntelCCompiler.preprocess\n",
      "    Preprocess a single C/C++ source file, named in 'source'.\n",
      "numpy.distutils.command.install.install.change_roots\n",
      "    Change the install directories pointed by name using root.\n",
      "numpy.polynomial.Chebyshev\n",
      "    A Chebyshev series class.\n",
      "numpy.polynomial.Polynomial\n",
      "    A power series class.\n",
      "numpy.distutils.command.config.config.check_funcs_once\n",
      "    Check a list of functions at once.\n",
      "numpy.polynomial.Chebyshev.__metaclass__.__instancecheck__\n",
      "    \n",
      "numpy.ma.MaskedArray.var\n",
      "    Compute the variance along the specified axis.\n",
      "numpy.testing.noseclasses.NumpyDocTestCase.assertIsInstance\n",
      "    default message.\n",
      "numpy.ma.MaskedArray.prod\n",
      "    Return the product of the array elements over the given axis.\n",
      "numpy.ma.MaskedArray.sort\n",
      "    Sort the array, in-place\n",
      "numpy.ma.MaskedArray.view\n",
      "    New view of array with the same data.\n",
      "numpy.distutils.command.install.install.handle_extra_path\n",
      "    Set `path_file` and `extra_dirs` using `extra_path`.\n",
      "numpy.testing.suppress_warnings\n",
      "    Context manager and decorator doing much the same as\n",
      "numpy.ma.MaskedArray.count\n",
      "    Count the non-masked elements of the array along the given axis.\n",
      "numpy.ma.MaskedArray.ravel\n",
      "    Returns a 1D version of self, as a view.\n",
      "numpy.lib.format.read_array\n",
      "    Read an array from an NPY file.\n",
      "numpy.ma.MaskedArray.cumsum\n",
      "    Return the cumulative sum of the array elements over the given axis.\n",
      "numpy.ma.MaskedArray.filled\n",
      "    Return a copy of self, with masked values filled with a given value.\n",
      "numpy.testing.noseclasses.NumpyDocTestCase.assertNotIsInstance\n",
      "    Included for symmetry with assertIsInstance.\n",
      "numpy.ma.MaskedArray.cumprod\n",
      "    Return the cumulative product of the array elements over the given axis.\n",
      "numpy.ma.MaskedArray.nonzero\n",
      "    Return the indices of unmasked elements that are not zero.\n",
      "numpy.ma.mrecords.fromarrays\n",
      "    Creates a mrecarray from a (flat) list of masked arrays.\n",
      "numpy.polynomial.Hermite.fit\n",
      "    Least squares fit to data.\n",
      "numpy.lib._iotools.easy_dtype\n",
      "    Convenience function to create a `np.dtype` object.\n",
      "numpy.testing.assert_array_max_ulp\n",
      "    Check that all items of arrays differ in at most N Units in the Last Place.\n",
      "numpy.ma.mrecords.fromrecords\n",
      "    Creates a MaskedRecords from a list of records.\n",
      "numpy.polynomial.Hermite._fit\n",
      "    Least squares fit of Hermite series to data.\n",
      "numpy.polynomial.Hermite._int\n",
      "    Integrate a Hermite series.\n",
      "numpy.polynomial.HermiteE.fit\n",
      "    Least squares fit to data.\n",
      "numpy.polynomial.Laguerre.fit\n",
      "    Least squares fit to data.\n",
      "numpy.polynomial.Legendre.fit\n",
      "    Least squares fit to data.\n",
      "numpy.ma.mrecords.fromtextfile\n",
      "    Creates a mrecarray from data stored in the file `filename`.\n",
      "numpy.polynomial.Chebyshev.fit\n",
      "    Least squares fit to data.\n",
      "numpy.polynomial.HermiteE._fit\n",
      "    Least squares fit of Hermite series to data.\n",
      "numpy.polynomial.HermiteE._int\n",
      "    Integrate a Hermite_e series.\n",
      "numpy.polynomial.Laguerre._fit\n",
      "    Least squares fit of Laguerre series to data.\n",
      "numpy.polynomial.Laguerre._int\n",
      "    Integrate a Laguerre series.\n",
      "numpy.polynomial.Legendre._fit\n",
      "    Least squares fit of Legendre series to data.\n",
      "numpy.polynomial.Legendre._int\n",
      "    Integrate a Legendre series.\n",
      "numpy.polynomial.Chebyshev._fit\n",
      "    Least squares fit of Chebyshev series to data.\n",
      "numpy.polynomial.Chebyshev._int\n",
      "    Integrate a Chebyshev series.\n",
      "numpy.polynomial.Polynomial.fit\n",
      "    Least squares fit to data.\n",
      "numpy.polynomial.Chebyshev.integ\n",
      "    Integrate.\n",
      "numpy.polynomial.Polynomial._fit\n",
      "    Least-squares fit of a polynomial to data.\n",
      "numpy.polynomial.Polynomial._int\n",
      "    Integrate a polynomial.\n",
      "numpy.distutils.extension.Extension\n",
      "    Just a collection of attributes that describes an extension\n",
      "numpy.lib._iotools.StringConverter\n",
      "    Factory class for function transforming a string into another object\n",
      "numpy.lib.arrayterator.Arrayterator\n",
      "    Buffered iterator for big arrays.\n",
      "numpy.polynomial.hermite.hermgauss\n",
      "    Gauss-Hermite quadrature.\n",
      "numpy.lib.recfunctions.merge_arrays\n",
      "    Merge arrays field by field.\n",
      "numpy.polynomial.laguerre.laggauss\n",
      "    Gauss-Laguerre quadrature.\n",
      "numpy.polynomial.legendre.leggauss\n",
      "    Gauss-Legendre quadrature.\n",
      "numpy.lib._iotools.ConversionWarning\n",
      "    Warning issued when a string converter has a problem.\n",
      "numpy.lib.recfunctions.append_fields\n",
      "    Add new fields to an existing array.\n",
      "numpy.polynomial.polyutils.trimcoef\n",
      "    Remove \"small\" \"trailing\" coefficients from a polynomial.\n",
      "numpy.distutils.numpy_distribution.NumpyDistribution._parse_command_opts\n",
      "    Parse the command-line options for a single command.\n",
      "numpy.polynomial.hermite_e.hermegauss\n",
      "    Gauss-HermiteE quadrature.\n",
      "numpy.polynomial._polybase.ABCPolyBase\n",
      "    An abstract base class for series classes.\n",
      "numpy.lib.recfunctions.rec_append_fields\n",
      "    Add new fields to an existing array.\n",
      "numpy.testing.noseclasses.NumpyTestProgram\n",
      "    Collect and run tests, returning success or failure.\n",
      "numpy.distutils.fcompiler.FCompiler.link\n",
      "    Link a bunch of stuff together to create an executable or\n",
      "numpy.distutils.ccompiler.simple_version_match\n",
      "    Simple matching of version numbers, for use in CCompiler and FCompiler.\n",
      "numpy.lib._datasource.Repository.abspath\n",
      "    Return absolute path of file in the Repository directory.\n",
      "numpy.lib._iotools.LineSplitter.autostrip\n",
      "    Wrapper to strip each member of the output of `method`.\n",
      "numpy.lib._iotools.StringConverter.update\n",
      "    Set StringConverter attributes directly.\n",
      "numpy.distutils.misc_util.Configuration.get_info\n",
      "    Get resources information.\n",
      "numpy.distutils.intelccompiler.IntelCCompiler.link\n",
      "    Link a bunch of stuff together to create an executable or\n",
      "numpy.distutils.intelccompiler.IntelCCompilerW.link\n",
      "    Link a bunch of stuff together to create an executable or\n",
      "numpy.distutils.misc_util.Configuration.add_library\n",
      "    Add library to configuration.\n",
      "numpy.distutils.command.sdist.sdist.add_defaults\n",
      "    Add all the default files to self.filelist:\n",
      "numpy.distutils.misc_util.Configuration.add_extension\n",
      "    Add extension to configuration.\n",
      "numpy.distutils.command.sdist.sdist.get_file_list\n",
      "    Figure out the list of files to include in the source\n",
      "numpy.distutils.misc_util.Configuration.add_data_files\n",
      "    Add data files to configuration data_files.\n",
      "numpy.distutils.misc_util.Configuration.add_npy_pkg_config\n",
      "    Generate and install a npy-pkg config file from a template.\n",
      "numpy.distutils.command.install.install.setuptools_run\n",
      "    The setuptools version of the .run() method.\n",
      "numpy.testing.noseclasses.NumpyOutputChecker.check_output\n",
      "    Return True iff the actual output from an example (`got`)\n",
      "numpy.distutils.numpy_distribution.NumpyDistribution.reinitialize_command\n",
      "    Reinitializes a command to the state it was in when first\n",
      "numpy.distutils.command.develop.develop.create_index.fetch_distribution\n",
      "    Obtain a distribution suitable for fulfilling `requirement`"
     ]
    }
   ],
   "source": [
    "np.lookfor('sin')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *linspace*\n",
    "\n",
    "You can create vectors uniformly spaced with linspace and the following syntax:\n",
    "```Python \n",
    "    np.linspace(start,end,step)\n",
    "```\n",
    "In this case, star and end points are included in the vector. Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "[  0.           0.66666667   1.33333333   2.           2.66666667\n",
      "   3.33333333   4.           4.66666667   5.33333333   6.           6.66666667\n",
      "   7.33333333   8.           8.66666667   9.33333333  10.        ]\n",
      "(16,)\n"
     ]
    }
   ],
   "source": [
    "x = np.linspace(0, 10, 16)\n",
    "print(type(x))\n",
    "print(x)\n",
    "print(x.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that you can see the dimension of the vector with the method **shape**. By default numpy creates arrays with only one dimension. To add an additional dimension you will have to use the method **reshape([dimension1, dimension2])**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 16)\n",
      "(4, 4)\n"
     ]
    }
   ],
   "source": [
    "print(x.reshape([1,16]).shape)\n",
    "print(x.reshape([-1,4]).shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that it is also possible to specify only one dimension and let numpy deduce the other by assigning one dimension as -1. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since numpy works with vectors, it is possible to use vector operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "y1 = x * 2\n",
    "y2 = np.sin(x)\n",
    "y3 = x ** 2 - 10 * x + 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Min and Max\n",
    "\n",
    "To find the minimum value and its index we can use **min** and **argmin**. The maximum and maximum index we can use **max** and **argmax**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-19.8888888889 -19.8888888889 -0.998954917098 4.66666666667\n"
     ]
    }
   ],
   "source": [
    "y3_min = y3.min()\n",
    "y3_argmin = y3.argmin()\n",
    "\n",
    "print(y3_min, y3[y3_argmin], y2[y3_argmin], x[y3_argmin])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other functions\n",
    "\n",
    "Numpy has a lot of fucntions and can do almost the same that Matlab does. A complete list of fucntions can be obtained with **dir**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ALLOW_THREADS',\n",
       " 'BUFSIZE',\n",
       " 'CLIP',\n",
       " 'ComplexWarning',\n",
       " 'DataSource',\n",
       " 'ERR_CALL',\n",
       " 'ERR_DEFAULT',\n",
       " 'ERR_IGNORE',\n",
       " 'ERR_LOG',\n",
       " 'ERR_PRINT',\n",
       " 'ERR_RAISE',\n",
       " 'ERR_WARN',\n",
       " 'FLOATING_POINT_SUPPORT',\n",
       " 'FPE_DIVIDEBYZERO',\n",
       " 'FPE_INVALID',\n",
       " 'FPE_OVERFLOW',\n",
       " 'FPE_UNDERFLOW',\n",
       " 'False_',\n",
       " 'Inf',\n",
       " 'Infinity',\n",
       " 'MAXDIMS',\n",
       " 'MAY_SHARE_BOUNDS',\n",
       " 'MAY_SHARE_EXACT',\n",
       " 'MachAr',\n",
       " 'ModuleDeprecationWarning',\n",
       " 'NAN',\n",
       " 'NINF',\n",
       " 'NZERO',\n",
       " 'NaN',\n",
       " 'PINF',\n",
       " 'PZERO',\n",
       " 'PackageLoader',\n",
       " 'RAISE',\n",
       " 'RankWarning',\n",
       " 'SHIFT_DIVIDEBYZERO',\n",
       " 'SHIFT_INVALID',\n",
       " 'SHIFT_OVERFLOW',\n",
       " 'SHIFT_UNDERFLOW',\n",
       " 'ScalarType',\n",
       " 'Tester',\n",
       " 'TooHardError',\n",
       " 'True_',\n",
       " 'UFUNC_BUFSIZE_DEFAULT',\n",
       " 'UFUNC_PYVALS_NAME',\n",
       " 'VisibleDeprecationWarning',\n",
       " 'WRAP',\n",
       " '_NoValue',\n",
       " '__NUMPY_SETUP__',\n",
       " '__all__',\n",
       " '__builtins__',\n",
       " '__cached__',\n",
       " '__config__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__git_revision__',\n",
       " '__loader__',\n",
       " '__mkl_version__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__path__',\n",
       " '__spec__',\n",
       " '__version__',\n",
       " '_distributor_init',\n",
       " '_globals',\n",
       " '_import_tools',\n",
       " '_mat',\n",
       " 'abs',\n",
       " 'absolute',\n",
       " 'absolute_import',\n",
       " 'add',\n",
       " 'add_docstring',\n",
       " 'add_newdoc',\n",
       " 'add_newdoc_ufunc',\n",
       " 'add_newdocs',\n",
       " 'alen',\n",
       " 'all',\n",
       " 'allclose',\n",
       " 'alltrue',\n",
       " 'alterdot',\n",
       " 'amax',\n",
       " 'amin',\n",
       " 'angle',\n",
       " 'any',\n",
       " 'append',\n",
       " 'apply_along_axis',\n",
       " 'apply_over_axes',\n",
       " 'arange',\n",
       " 'arccos',\n",
       " 'arccosh',\n",
       " 'arcsin',\n",
       " 'arcsinh',\n",
       " 'arctan',\n",
       " 'arctan2',\n",
       " 'arctanh',\n",
       " 'argmax',\n",
       " 'argmin',\n",
       " 'argpartition',\n",
       " 'argsort',\n",
       " 'argwhere',\n",
       " 'around',\n",
       " 'array',\n",
       " 'array2string',\n",
       " 'array_equal',\n",
       " 'array_equiv',\n",
       " 'array_repr',\n",
       " 'array_split',\n",
       " 'array_str',\n",
       " 'asanyarray',\n",
       " 'asarray',\n",
       " 'asarray_chkfinite',\n",
       " 'ascontiguousarray',\n",
       " 'asfarray',\n",
       " 'asfortranarray',\n",
       " 'asmatrix',\n",
       " 'asscalar',\n",
       " 'atleast_1d',\n",
       " 'atleast_2d',\n",
       " 'atleast_3d',\n",
       " 'average',\n",
       " 'bartlett',\n",
       " 'base_repr',\n",
       " 'bench',\n",
       " 'binary_repr',\n",
       " 'bincount',\n",
       " 'bitwise_and',\n",
       " 'bitwise_not',\n",
       " 'bitwise_or',\n",
       " 'bitwise_xor',\n",
       " 'blackman',\n",
       " 'bmat',\n",
       " 'bool',\n",
       " 'bool8',\n",
       " 'bool_',\n",
       " 'broadcast',\n",
       " 'broadcast_arrays',\n",
       " 'broadcast_to',\n",
       " 'busday_count',\n",
       " 'busday_offset',\n",
       " 'busdaycalendar',\n",
       " 'byte',\n",
       " 'byte_bounds',\n",
       " 'bytes0',\n",
       " 'bytes_',\n",
       " 'c_',\n",
       " 'can_cast',\n",
       " 'cast',\n",
       " 'cbrt',\n",
       " 'cdouble',\n",
       " 'ceil',\n",
       " 'cfloat',\n",
       " 'char',\n",
       " 'character',\n",
       " 'chararray',\n",
       " 'choose',\n",
       " 'clip',\n",
       " 'clongdouble',\n",
       " 'clongfloat',\n",
       " 'column_stack',\n",
       " 'common_type',\n",
       " 'compare_chararrays',\n",
       " 'compat',\n",
       " 'complex',\n",
       " 'complex128',\n",
       " 'complex64',\n",
       " 'complex_',\n",
       " 'complexfloating',\n",
       " 'compress',\n",
       " 'concatenate',\n",
       " 'conj',\n",
       " 'conjugate',\n",
       " 'convolve',\n",
       " 'copy',\n",
       " 'copysign',\n",
       " 'copyto',\n",
       " 'core',\n",
       " 'corrcoef',\n",
       " 'correlate',\n",
       " 'cos',\n",
       " 'cosh',\n",
       " 'count_nonzero',\n",
       " 'cov',\n",
       " 'cross',\n",
       " 'csingle',\n",
       " 'ctypeslib',\n",
       " 'cumprod',\n",
       " 'cumproduct',\n",
       " 'cumsum',\n",
       " 'datetime64',\n",
       " 'datetime_as_string',\n",
       " 'datetime_data',\n",
       " 'deg2rad',\n",
       " 'degrees',\n",
       " 'delete',\n",
       " 'deprecate',\n",
       " 'deprecate_with_doc',\n",
       " 'diag',\n",
       " 'diag_indices',\n",
       " 'diag_indices_from',\n",
       " 'diagflat',\n",
       " 'diagonal',\n",
       " 'diff',\n",
       " 'digitize',\n",
       " 'disp',\n",
       " 'distutils',\n",
       " 'divide',\n",
       " 'division',\n",
       " 'doc',\n",
       " 'dot',\n",
       " 'double',\n",
       " 'dsplit',\n",
       " 'dstack',\n",
       " 'dtype',\n",
       " 'dual',\n",
       " 'e',\n",
       " 'ediff1d',\n",
       " 'einsum',\n",
       " 'einsum_path',\n",
       " 'emath',\n",
       " 'empty',\n",
       " 'empty_like',\n",
       " 'equal',\n",
       " 'errstate',\n",
       " 'euler_gamma',\n",
       " 'exp',\n",
       " 'exp2',\n",
       " 'expand_dims',\n",
       " 'expm1',\n",
       " 'extract',\n",
       " 'eye',\n",
       " 'f2py',\n",
       " 'fabs',\n",
       " 'fastCopyAndTranspose',\n",
       " 'fft',\n",
       " 'fill_diagonal',\n",
       " 'find_common_type',\n",
       " 'finfo',\n",
       " 'fix',\n",
       " 'flatiter',\n",
       " 'flatnonzero',\n",
       " 'flexible',\n",
       " 'flip',\n",
       " 'fliplr',\n",
       " 'flipud',\n",
       " 'float',\n",
       " 'float16',\n",
       " 'float32',\n",
       " 'float64',\n",
       " 'float_',\n",
       " 'float_power',\n",
       " 'floating',\n",
       " 'floor',\n",
       " 'floor_divide',\n",
       " 'fmax',\n",
       " 'fmin',\n",
       " 'fmod',\n",
       " 'format_parser',\n",
       " 'frexp',\n",
       " 'frombuffer',\n",
       " 'fromfile',\n",
       " 'fromfunction',\n",
       " 'fromiter',\n",
       " 'frompyfunc',\n",
       " 'fromregex',\n",
       " 'fromstring',\n",
       " 'full',\n",
       " 'full_like',\n",
       " 'fv',\n",
       " 'generic',\n",
       " 'genfromtxt',\n",
       " 'geomspace',\n",
       " 'get_array_wrap',\n",
       " 'get_include',\n",
       " 'get_printoptions',\n",
       " 'getbufsize',\n",
       " 'geterr',\n",
       " 'geterrcall',\n",
       " 'geterrobj',\n",
       " 'gradient',\n",
       " 'greater',\n",
       " 'greater_equal',\n",
       " 'half',\n",
       " 'hamming',\n",
       " 'hanning',\n",
       " 'histogram',\n",
       " 'histogram2d',\n",
       " 'histogramdd',\n",
       " 'hsplit',\n",
       " 'hstack',\n",
       " 'hypot',\n",
       " 'i0',\n",
       " 'identity',\n",
       " 'iinfo',\n",
       " 'imag',\n",
       " 'in1d',\n",
       " 'index_exp',\n",
       " 'indices',\n",
       " 'inexact',\n",
       " 'inf',\n",
       " 'info',\n",
       " 'infty',\n",
       " 'inner',\n",
       " 'insert',\n",
       " 'int',\n",
       " 'int0',\n",
       " 'int16',\n",
       " 'int32',\n",
       " 'int64',\n",
       " 'int8',\n",
       " 'int_',\n",
       " 'int_asbuffer',\n",
       " 'intc',\n",
       " 'integer',\n",
       " 'interp',\n",
       " 'intersect1d',\n",
       " 'intp',\n",
       " 'invert',\n",
       " 'ipmt',\n",
       " 'irr',\n",
       " 'is_busday',\n",
       " 'isclose',\n",
       " 'iscomplex',\n",
       " 'iscomplexobj',\n",
       " 'isfinite',\n",
       " 'isfortran',\n",
       " 'isinf',\n",
       " 'isnan',\n",
       " 'isneginf',\n",
       " 'isposinf',\n",
       " 'isreal',\n",
       " 'isrealobj',\n",
       " 'isscalar',\n",
       " 'issctype',\n",
       " 'issubclass_',\n",
       " 'issubdtype',\n",
       " 'issubsctype',\n",
       " 'iterable',\n",
       " 'ix_',\n",
       " 'kaiser',\n",
       " 'kron',\n",
       " 'ldexp',\n",
       " 'left_shift',\n",
       " 'less',\n",
       " 'less_equal',\n",
       " 'lexsort',\n",
       " 'lib',\n",
       " 'linalg',\n",
       " 'linspace',\n",
       " 'little_endian',\n",
       " 'load',\n",
       " 'loads',\n",
       " 'loadtxt',\n",
       " 'log',\n",
       " 'log10',\n",
       " 'log1p',\n",
       " 'log2',\n",
       " 'logaddexp',\n",
       " 'logaddexp2',\n",
       " 'logical_and',\n",
       " 'logical_not',\n",
       " 'logical_or',\n",
       " 'logical_xor',\n",
       " 'logspace',\n",
       " 'long',\n",
       " 'longcomplex',\n",
       " 'longdouble',\n",
       " 'longfloat',\n",
       " 'longlong',\n",
       " 'lookfor',\n",
       " 'ma',\n",
       " 'mafromtxt',\n",
       " 'mask_indices',\n",
       " 'mat',\n",
       " 'math',\n",
       " 'matlib',\n",
       " 'matmul',\n",
       " 'matrix',\n",
       " 'matrixlib',\n",
       " 'max',\n",
       " 'maximum',\n",
       " 'maximum_sctype',\n",
       " 'may_share_memory',\n",
       " 'mean',\n",
       " 'median',\n",
       " 'memmap',\n",
       " 'meshgrid',\n",
       " 'mgrid',\n",
       " 'min',\n",
       " 'min_scalar_type',\n",
       " 'minimum',\n",
       " 'mintypecode',\n",
       " 'mirr',\n",
       " 'mod',\n",
       " 'modf',\n",
       " 'moveaxis',\n",
       " 'msort',\n",
       " 'multiply',\n",
       " 'nan',\n",
       " 'nan_to_num',\n",
       " 'nanargmax',\n",
       " 'nanargmin',\n",
       " 'nancumprod',\n",
       " 'nancumsum',\n",
       " 'nanmax',\n",
       " 'nanmean',\n",
       " 'nanmedian',\n",
       " 'nanmin',\n",
       " 'nanpercentile',\n",
       " 'nanprod',\n",
       " 'nanstd',\n",
       " 'nansum',\n",
       " 'nanvar',\n",
       " 'nbytes',\n",
       " 'ndarray',\n",
       " 'ndenumerate',\n",
       " 'ndfromtxt',\n",
       " 'ndim',\n",
       " 'ndindex',\n",
       " 'nditer',\n",
       " 'negative',\n",
       " 'nested_iters',\n",
       " 'newaxis',\n",
       " 'nextafter',\n",
       " 'nonzero',\n",
       " 'not_equal',\n",
       " 'nper',\n",
       " 'npv',\n",
       " 'numarray',\n",
       " 'number',\n",
       " 'obj2sctype',\n",
       " 'object',\n",
       " 'object0',\n",
       " 'object_',\n",
       " 'ogrid',\n",
       " 'oldnumeric',\n",
       " 'ones',\n",
       " 'ones_like',\n",
       " 'outer',\n",
       " 'packbits',\n",
       " 'pad',\n",
       " 'partition',\n",
       " 'percentile',\n",
       " 'pi',\n",
       " 'piecewise',\n",
       " 'pkgload',\n",
       " 'place',\n",
       " 'pmt',\n",
       " 'poly',\n",
       " 'poly1d',\n",
       " 'polyadd',\n",
       " 'polyder',\n",
       " 'polydiv',\n",
       " 'polyfit',\n",
       " 'polyint',\n",
       " 'polymul',\n",
       " 'polynomial',\n",
       " 'polysub',\n",
       " 'polyval',\n",
       " 'power',\n",
       " 'ppmt',\n",
       " 'print_function',\n",
       " 'prod',\n",
       " 'product',\n",
       " 'promote_types',\n",
       " 'ptp',\n",
       " 'put',\n",
       " 'putmask',\n",
       " 'pv',\n",
       " 'r_',\n",
       " 'rad2deg',\n",
       " 'radians',\n",
       " 'random',\n",
       " 'rank',\n",
       " 'rate',\n",
       " 'ravel',\n",
       " 'ravel_multi_index',\n",
       " 'real',\n",
       " 'real_if_close',\n",
       " 'rec',\n",
       " 'recarray',\n",
       " 'recfromcsv',\n",
       " 'recfromtxt',\n",
       " 'reciprocal',\n",
       " 'record',\n",
       " 'remainder',\n",
       " 'repeat',\n",
       " 'require',\n",
       " 'reshape',\n",
       " 'resize',\n",
       " 'restoredot',\n",
       " 'result_type',\n",
       " 'right_shift',\n",
       " 'rint',\n",
       " 'roll',\n",
       " 'rollaxis',\n",
       " 'roots',\n",
       " 'rot90',\n",
       " 'round',\n",
       " 'round_',\n",
       " 'row_stack',\n",
       " 's_',\n",
       " 'safe_eval',\n",
       " 'save',\n",
       " 'savetxt',\n",
       " 'savez',\n",
       " 'savez_compressed',\n",
       " 'sctype2char',\n",
       " 'sctypeDict',\n",
       " 'sctypeNA',\n",
       " 'sctypes',\n",
       " 'searchsorted',\n",
       " 'select',\n",
       " 'set_numeric_ops',\n",
       " 'set_printoptions',\n",
       " 'set_string_function',\n",
       " 'setbufsize',\n",
       " 'setdiff1d',\n",
       " 'seterr',\n",
       " 'seterrcall',\n",
       " 'seterrobj',\n",
       " 'setup',\n",
       " 'setxor1d',\n",
       " 'shape',\n",
       " 'shares_memory',\n",
       " 'short',\n",
       " 'show_config',\n",
       " 'sign',\n",
       " 'signbit',\n",
       " 'signedinteger',\n",
       " 'sin',\n",
       " 'sinc',\n",
       " 'single',\n",
       " 'singlecomplex',\n",
       " 'sinh',\n",
       " 'size',\n",
       " 'sometrue',\n",
       " 'sort',\n",
       " 'sort_complex',\n",
       " 'source',\n",
       " 'spacing',\n",
       " 'split',\n",
       " 'sqrt',\n",
       " 'square',\n",
       " 'squeeze',\n",
       " 'stack',\n",
       " 'std',\n",
       " 'str',\n",
       " 'str0',\n",
       " 'str_',\n",
       " 'string_',\n",
       " 'subtract',\n",
       " 'sum',\n",
       " 'swapaxes',\n",
       " 'sys',\n",
       " 'take',\n",
       " 'tan',\n",
       " 'tanh',\n",
       " 'tensordot',\n",
       " 'test',\n",
       " 'testing',\n",
       " 'tile',\n",
       " 'timedelta64',\n",
       " 'trace',\n",
       " 'transpose',\n",
       " 'trapz',\n",
       " 'tri',\n",
       " 'tril',\n",
       " 'tril_indices',\n",
       " 'tril_indices_from',\n",
       " 'trim_zeros',\n",
       " 'triu',\n",
       " 'triu_indices',\n",
       " 'triu_indices_from',\n",
       " 'true_divide',\n",
       " 'trunc',\n",
       " 'typeDict',\n",
       " 'typeNA',\n",
       " 'typecodes',\n",
       " 'typename',\n",
       " 'ubyte',\n",
       " 'ufunc',\n",
       " 'uint',\n",
       " 'uint0',\n",
       " 'uint16',\n",
       " 'uint32',\n",
       " 'uint64',\n",
       " 'uint8',\n",
       " 'uintc',\n",
       " 'uintp',\n",
       " 'ulonglong',\n",
       " 'unicode',\n",
       " 'unicode_',\n",
       " 'union1d',\n",
       " 'unique',\n",
       " 'unpackbits',\n",
       " 'unravel_index',\n",
       " 'unsignedinteger',\n",
       " 'unwrap',\n",
       " 'ushort',\n",
       " 'vander',\n",
       " 'var',\n",
       " 'vdot',\n",
       " 'vectorize',\n",
       " 'version',\n",
       " 'void',\n",
       " 'void0',\n",
       " 'vsplit',\n",
       " 'vstack',\n",
       " 'warnings',\n",
       " 'where',\n",
       " 'who',\n",
       " 'zeros',\n",
       " 'zeros_like']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(np)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating arrays by using lists\n",
    "\n",
    "You can create arrays by using list with **array** function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>[1 2 3 4 5]\n",
      "\n",
      "[[1 2 3 4]\n",
      " [5 6 7 8]]\n",
      "[[0 1 0]\n",
      " [1 0 0]\n",
      " [0 0 1]]\n"
     ]
    }
   ],
   "source": [
    "list1 = [1, 2, 3, 4, 5]\n",
    "array1 = np.array(list1)\n",
    "\n",
    "list2d = [[1, 2, 3, 4], [5, 6, 7, 8]]\n",
    "array2d = np.array(list2d)\n",
    "\n",
    "print(f'{type(array1)}{array1}\\n\\n{array2d}')\n",
    "print(np.array([[0,1,0],[1,0,0],[0,0,1]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accessing and changing elements\n",
    "\n",
    "In 1d arrays you can access to the elements with **array[index]**. In 2d arrays you can access with **array[index1,index2]** or **array[index1][index2]**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "item1 = array2d[0][1]\n",
    "item2 = array2d[0, 1]\n",
    "print(item1 == item2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Slicing* works in the same form as in the lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 3],\n",
       "       [6, 7]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "middle = array2d[0:2, 1:3]\n",
    "middle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is important to note that the slices in `arrays` return a *reference* to the array, not a copy, as in lists. Therefore, if you change a value of this reference, the original array is changed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original:\n",
      " [[1 2 3 4]\n",
      " [5 6 7 8]]\n",
      "Changed:\n",
      " [[1 0 0 4]\n",
      " [5 0 0 8]]\n"
     ]
    }
   ],
   "source": [
    "array2d = np.array(list2d)\n",
    "print('Original:\\n', array2d)\n",
    "middle = array2d[0:2, 1:3]\n",
    "middle[:, :] = [[0, 0], [0, 0]]\n",
    "print('Changed:\\n', array2d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To avoid that it is necessary create a copy of the array with  **copy()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original:\n",
      " [[1 2 3 4]\n",
      " [5 6 7 8]]\n",
      "Not changed:\n",
      " [[1 2 3 4]\n",
      " [5 6 7 8]]\n"
     ]
    }
   ],
   "source": [
    "array2d = np.array(list2d)\n",
    "print('Original:\\n', array2d)\n",
    "\n",
    "middle = array2d[0:2, 1:3].copy()\n",
    "middle[:, :] = [[0, 0], [0, 0]]\n",
    "\n",
    "print('Not changed:\\n', array2d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *random*\n",
    "\n",
    "Random is a package inside numpy. The role of random functions is to provide a way to choose a value from a list at random, or to generate random values. Run the following cell several times to see the values change."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.86; 2.00; 4.00\n"
     ]
    }
   ],
   "source": [
    "r1 = np.random.random()  # random number between 0 and 1\n",
    "r2 = np.random.choice(array1)  # Chose a random element in a list\n",
    "r3 = np.random.randint(5)  # random number between 0 and 5\n",
    "\n",
    "print(f'{r1:.2f}; {r2:.2f}; {r3:.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Constants\n",
    "\n",
    "Numpy has some constans included:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pi:3.141592653589793,\n",
      "e:2.718281828459045\n"
     ]
    }
   ],
   "source": [
    "print(f'Pi:{np.pi},\\ne:{np.e}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arrays multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c:\n",
      " [[1 2]\n",
      " [6 7]] \n",
      "\n",
      "d:\n",
      " [[3 1]\n",
      " [2 1]] \n",
      "\n",
      "Bitwise multiplication\n",
      " [[ 3  2]\n",
      " [12  7]] \n",
      "\n",
      "Dot product\n",
      " [[ 7  3]\n",
      " [32 13]] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "c = np.array([[1, 2], [6, 7]])\n",
    "d = np.array([[3, 1], [2, 1]])\n",
    "\n",
    "print('c:\\n', c,'\\n\\nd:\\n', d, '\\n')\n",
    "\n",
    " # Bitwise\n",
    "print('Bitwise multiplication\\n', c * d, '\\n')\n",
    "\n",
    "# Dot product\n",
    "print('Dot product\\n', np.dot(c, d), '\\n') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy is also able to use C/C++/Fortran code to Python to increase the efficiency of its functions. See their website for more information [here](http://www.numpy.org/). You can also see more differences with matlab [here](https://docs.scipy.org/doc/numpy/user/numpy-for-matlab-users.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise\n",
    "Using numpy create the matrix $Z$ and $T$ with $z_p$ and $z_m$ equal to any constant, and a = $e^{j2\\pi/3}$. Then do $T^{-1}ZT$ and print the diagonal elements of the result. \n",
    "\n",
    "$$\n",
    "Z = \\left[\\begin{array}{ccc} \n",
    "z_p & z_m & z_m\\\\\n",
    "z_m & z_p & z_m\\\\\n",
    "z_m & z_m & z_p\\\\\n",
    "\\end{array}\\right]\n",
    "\\quad\n",
    "T = \\left[\\begin{array}{ccc} \n",
    "1 & 1 & 1\\\\\n",
    "1 & a^2 & a\\\\\n",
    "1 & a & a^2\\\\\n",
    "\\end{array}\\right]\n",
    "$$ \n",
    "\n",
    "Tips: \n",
    "- I am asking for a matrix and not a 2 dimensional array      \n",
    "- All objects have their own built in methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Index",
   "title_sidebar": "Index",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}