3. The Basics Numpy and Universal Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy’s main object is the homogeneous multidimensional array. It is a table of elements (usually numbers), all of the same type, indexed by a tuple of positive integers. In NumPy dimensions are called axes.\n",
    "\n",
    "For example, the coordinates of a point in 3D space [1, 2, 1] has one axis. That axis has 3 elements in it, so we say it has a length of 3. In the example pictured below, the array has 2 axes. The first axis has a length of 2, the second axis has a length of 3."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "[[ 1., 0., 0.],\n",
    " [ 0., 1., 2.]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy’s array class is called ndarray. It is also known by the alias array. Note that numpy.array is not the same as the Standard Python Library class array.array, which only handles one-dimensional arrays and offers less functionality. The more important attributes of an ndarray object are:\n",
    "\n",
    "#### ndarray.ndim\n",
    "\n",
    "the number of axes (dimensions) of the array.\n",
    "\n",
    "#### ndarray.shape\n",
    "\n",
    "the dimensions of the array. This is a tuple of integers indicating the size of the array in each dimension. For a matrix with n rows and m columns, shape will be (n,m). The length of the shape tuple is therefore the number of axes, ndim.\n",
    "\n",
    "#### ndarray.size\n",
    "\n",
    "the total number of elements of the array. This is equal to the product of the elements of shape.\n",
    "\n",
    "#### ndarray.dtype\n",
    "\n",
    "an object describing the type of the elements in the array. One can create or specify dtype’s using standard Python types. Additionally NumPy provides types of its own. numpy.int32, numpy.int16, and numpy.float64 are some examples.\n",
    "\n",
    "#### ndarray.itemsize\n",
    "\n",
    "the size in bytes of each element of the array. For example, an array of elements of type float64 has itemsize 8 (=64/8), while one of type complex32 has itemsize 4 (=32/8). It is equivalent to ndarray.dtype.itemsize.\n",
    "\n",
    "#### ndarray.data\n",
    "\n",
    "the buffer containing the actual elements of the array. Normally, we won’t need to use this attribute because we will access the elements in an array using indexing facilities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.array([6, 7, 8])\n",
    "a = np.arange(15).reshape(3, 5)\n",
    "print(a.shape,\"Shape of 'a' array\\n\")\n",
    "print(a.ndim,\"Dimension of an array\\n\")\n",
    "print(a.dtype.name,\"Data type\\n \")\n",
    "print(a.itemsize,\"Find the iteamsize in array\\n \")\n",
    "print(a.size,\"size oF an array\\n\")\n",
    "print(type(a))\n",
    "print(type(b),b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array Creation\n",
    "There are several ways to create arrays.\n",
    "\n",
    "For example, you can create an array from a regular Python list or tuple using the array function. The type of the resulting array is deduced from the type of the elements in the sequences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "a = np.array([2,3,4])\n",
    "print(a.dtype)\n",
    "b = np.array([1.2, 3.5, 5.1])\n",
    "print(b.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A frequent error consists in calling array with multiple numeric arguments, rather than providing a single list of numbers as an argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#a = np.array(1,2,3,4)    # WRONG\n",
    "a = np.array([1,2,3,4])  # RIGHT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "array transforms sequences of sequences into two-dimensional arrays, sequences of sequences of sequences into three-dimensional arrays, and so on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.array([(1.5,2,3), (4,5,6)])\n",
    "b.size\n",
    "b.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The type of the array can also be explicitly specified at creation time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = np.array( [ [1,2], [3,4] ], dtype=complex )\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often, the elements of an array are originally unknown, but its size is known. Hence, NumPy offers several functions to create arrays with initial placeholder content. These minimize the necessity of growing arrays, an expensive operation.\n",
    "\n",
    "The function zeros creates an array full of zeros, the function ones creates an array full of ones, and the function empty creates an array whose initial content is random and depends on the state of the memory. By default, the dtype of the created array is float64."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.zeros((3,4))\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.ones( (2,3,4), dtype=np.int16 )\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = np.empty( (2,3) )\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e = np.arange( 10, 30, 5 )\n",
    "print(e)\n",
    "f = np.arange( 0, 2, 0.3 ) \n",
    "print(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import pi\n",
    "g = np.linspace( 0, 2, 9) \n",
    "print(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xy = np.linspace( 0, 2*pi, 10) \n",
    "print(xy,\"xy Variable has linspace is\\n\")\n",
    "f = np.sin(xy)\n",
    "print(xy,\"linspace with pi\\n\",f,\"sin on xy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Printing Arrays\n",
    "When you print an array, NumPy displays it in a similar way to nested lists, but with the following layout:\n",
    "\n",
    "the last axis is printed from left to right,\n",
    "the second-to-last is printed from top to bottom,\n",
    "the rest are also printed from top to bottom, with each slice separated from the next by an empty line.\n",
    "One-dimensional arrays are then printed as rows, bidimensionals as matrices and tridimensionals as lists of matrices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(6)                         # 1d array\n",
    "print(a,'1d array\\n')\n",
    "\n",
    "b = np.arange(12).reshape(4,3)           # 2d array\n",
    "print(b,\"2d array\\n\")\n",
    "\n",
    "c = np.arange(24).reshape(2,3,4)         # 3d array\n",
    "print(c,\"3d array\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If an array is too large to be printed, NumPy automatically skips the central part of the array and only prints the corners:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.arange(10000),\"\\nPrinting all range of values from 0 to 10000\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.arange(10000).reshape(100,100),\"\\nPrinting all range of values from 0 to 10000\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To disable this behaviour and force NumPy to print the entire array, you can change the printing options using set_printoptions."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "np.set_printoptions(threshold=np.nan)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Operations\n",
    "Arithmetic operators on arrays apply elementwise. A new array is created and filled with the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "aa = np.array( [20,30,40,50] )\n",
    "bc = np.arange( 4 )\n",
    "#print(aa,bc)\n",
    "print(aa-bc,\"Sub of Two arrays\\n\")\n",
    "print(np.subtract(aa,bc),\"Sub of Two arrays\\n\")\n",
    "print(np.add(aa,bc),\"Addation of two arrays\\n\")\n",
    "print(aa+bc,\"\\n\")\n",
    "print(np.multiply(aa,bc),\"Mul of two arrays\\n\")\n",
    "print(aa*bc,\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.divide(aa,bc),\"aa number divide with bc numbers\")\n",
    "print(aa/bc,\"div\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.divmod(aa,bc),\"Divmode\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bc**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "10*np.sin(aa)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(aa<35,\"Comp\")\n",
    "print(aa>35,\"Comp\")\n",
    "print(aa==bc,\"comp\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike in many matrix languages, the product operator * operates elementwise in NumPy arrays. The matrix product can be performed using the @ operator (in python >=3.5) or the dot function or method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array( [[1,1],[0,1]] )\n",
    "B = np.array( [[2,0],[3,4]] )\n",
    "print(A * B ,\"# elementwise product\\n\")\n",
    "print(A @ B ,\"# matrix product\\n\")\n",
    "print(A.dot(B),\"# another matrix product\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some operations, such as += and *=, act in place to modify an existing array rather than create a new one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.ones((2,3), dtype=int)\n",
    "b = np.random.random((2,3))\n",
    "a *= 3\n",
    "b += a\n",
    "print(\"Assignement operaters Mul\\n\",a)\n",
    "print(\"Assignement operaters ADD\\n\",b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When operating with arrays of different types, the type of the resulting array corresponds to the more general or precise one (a behavior known as upcasting)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.ones(3, dtype=np.int32)\n",
    "b = np.linspace(0,pi,3)\n",
    "c =a+b\n",
    "print(b.dtype.name,\"Data type\\n\")\n",
    "print(\"Add of two arrays\\n\",c)\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many unary operations, such as computing the sum of all the elements in the array, are implemented as methods of the ndarray class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.random.random((2,3))\n",
    "print(a.sum(),\"Sum of number\")\n",
    "print(a.min(),\"Find the min\")\n",
    "print(a.max(),\"Max of from array\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, these operations apply to the array as though it were a list of numbers, regardless of its shape. However, by specifying the axis parameter you can apply an operation along the specified axis of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.arange(12).reshape(3,4)\n",
    "print(b.sum(axis=0) ,\"# sum of each column\")\n",
    "print(b.min(axis=1) ,\"# min of each row\")\n",
    "print(b.cumsum(axis=1),\"# cumulative sum along each row\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Universal Functions\n",
    "NumPy provides familiar mathematical functions such as sin, cos, and exp. In NumPy, these are called “universal functions”(ufunc). Within NumPy, these functions operate elementwise on an array, producing an array as output.\n",
    "* all, \n",
    "* any, \n",
    "* apply_along_axis, \n",
    "* argmax, \n",
    "* argmin, \n",
    "* argsort, \n",
    "* average, \n",
    "* bincount, \n",
    "* ceil, \n",
    "* clip, \n",
    "* conj, \n",
    "* corrcoef, \n",
    "* cov, \n",
    "* cross, \n",
    "* cumprod, \n",
    "* cumsum, \n",
    "* diff, \n",
    "* dot, \n",
    "* floor, \n",
    "* inner, \n",
    "* inv, \n",
    "* lexsort, \n",
    "* max, \n",
    "* maximum, \n",
    "* mean, \n",
    "* median, \n",
    "* min, \n",
    "* minimum, \n",
    "* nonzero, \n",
    "* outer, \n",
    "* prod, \n",
    "* re, \n",
    "* round, \n",
    "* sort, \n",
    "* std, \n",
    "* sum, \n",
    "* trace, \n",
    "* transpose, \n",
    "* var, \n",
    "* vdot, \n",
    "* vectorize, \n",
    "* where"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = np.arange(3)\n",
    "C = np.arange(3)\n",
    "print(np.exp(B),\"Exp of Array\")\n",
    "print(np.sqrt(B),\"Square root of a array\")\n",
    "print(np.add(B, C),\"Addition of Two Arrays\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Numpy all and any \n",
    "Test whether all array elements along a given axis evaluate to True.\n",
    "\n",
    "Test whether any array element along a given axis evaluates to True.\n",
    "\n",
    "Returns single boolean unless axis is not None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test whether all array elements along a given axis evaluate to True.\n",
    "print(np.all([[True,False],[True,True]]))\n",
    "print(np.any([[True, False], [True, True]]))\n",
    "np.any(np.nan)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### numpy.apply_along_axis\n",
    "\n",
    "Apply a function to 1-D slices along the given axis.\n",
    "\n",
    "Execute func1d(a, *args) where func1d operates on 1-D arrays and a is a 1-D slice of arr along axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.array([[1,2,3], [4,5,6], [7,8,9]])\n",
    "np.apply_along_axis(np.diag, -1, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  argmax, argmin, argsort,\n",
    "Returns the indices of the maximum values along an axis.\n",
    "\n",
    "Returns the indices of the minimum values along an axis.\n",
    "\n",
    "Returns the indices that would sort an array.\n",
    "\n",
    "Perform an indirect sort along the given axis using the algorithm specified by the kind keyword. It returns an array of indices of the same shape as a that index data along the given axis in sorted order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(6).reshape(2,3) + 10\n",
    "print(a, \"Print all a array  values\\n\")\n",
    "print(\"Index of 'max of a' values:  \",np.argmax(a) )\n",
    "print(\"Index of 'max of a' values with axis zero:  \",np.argmax(a, axis=0))\n",
    "print(\"Index of 'max of a' values with axis one:  \",np.argmax(a, axis=1))\n",
    "# axis 2 is out of bounds for array of dimension 2\n",
    "#print(\"Index of 'max of a' values with axis zero:  \",np.argmax(a, axis=2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(6).reshape(2,3) + 10\n",
    "print(\"Index of 'min of a' values:  \",np.argmin(a) )\n",
    "print(\"Index of 'min of a' values with axis zero:  \",np.argmin(a, axis=0))\n",
    "print(\"Index of 'min of a' values with axis one:  \",np.argmin(a, axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([3, 1, 2])\n",
    "print(np.argsort(x),\"Arg Sorting of a number\\n\")\n",
    "print(np.argsort(x, axis=0) ,\"# sorts along first axis (down)\\n\")\n",
    "x = np.array([[0, 3], [2, 2]])\n",
    "print(np.argsort(x, axis=1) ,\"# sorts along last axis (across)\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Average\n",
    "\n",
    "Compute the weighted average along the specified axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = range(1,5)\n",
    "print(np.average(data))\n",
    "c =np.average(range(1,11), weights=range(10,0,-1))\n",
    "print(c)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### bincount\n",
    "\n",
    "Count number of occurrences of each value in array of non-negative ints.\n",
    "\n",
    "The number of bins (of size 1) is one larger than the largest value in x. If minlength is specified, there will be at least this number of bins in the output array (though it will be longer if necessary, depending on the contents of x). Each bin gives the number of occurrences of its index value in x. If weights is specified the input array is weighted by it, i.e. if a value n is found at position i, out[n] += weight[i] instead of out[n] += 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.bincount(np.arange(5))\n",
    "b = np.bincount(np.array([0, 1, 1, 3, 2, 1, 7]))\n",
    "print(a,\"\\n\",\"\\n\",b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ceil\n",
    "Return the ceiling of the input, element-wise.\n",
    "\n",
    "The ceil of the scalar x is the smallest integer i, such that i >= x. It is often denoted as \\lceil x \\rceil."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])\n",
    "print(np.ceil(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Clip\n",
    "Clip (limit) the values in an array.\n",
    "\n",
    "Given an interval, values outside the interval are clipped to the interval edges. For example, if an interval of [0, 1] is specified, values smaller than 0 become 0, and values larger than 1 become 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(10)\n",
    "np.clip(a, 1, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.clip(a, 3, 6, out=a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### numpy.conj\n",
    "Return the complex conjugate, element-wise.\n",
    "\n",
    "The complex conjugate of a complex number is obtained by changing the sign of its imaginary part."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.conjugate(1+2j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.eye(2) + 1j * np.eye(2)\n",
    "np.conjugate(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### correlation coefficients\n",
    "Return Pearson product-moment correlation coefficients.\n",
    "\n",
    "Please refer to the documentation for cov for more detail. The relationship between the correlation coefficient matrix, R, and the covariance matrix, C, is"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "The covariance matrix is the matrix\n",
    "\n",
    "Cov( X, X )    Cov( X, Y )\n",
    "\n",
    "Cov( Y, X )    Cov( Y, Y )\n",
    "\n",
    "Normalised, this will yield the matrix:\n",
    "\n",
    "Corr( X, X )    Corr( X, Y )\n",
    "\n",
    "Corr( Y, X )    Corr( Y, Y )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'x' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-3-286bab3debee>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcorrcoef\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'x' is not defined"
     ]
    }
   ],
   "source": [
    "np.corrcoef(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Cross Product\n",
    "Return the cross product of two (arrays of) vectors.\n",
    "\n",
    "The cross product of a and b in R^3 is a vector perpendicular to both a and b. If a and b are arrays of vectors, the vectors are defined by the last axis of a and b by default, and these axes can have dimensions 2 or 3. Where the dimension of either a or b is 2, the third component of the input vector is assumed to be zero and the cross product calculated accordingly. In cases where both input vectors have dimension 2, the z-component of the cross product is returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3,  6, -3])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [1, 2, 3]\n",
    "y = [4, 5, 6]\n",
    "np.cross(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-3,  6, -3],\n",
       "       [ 3, -6,  3]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([[1,2,3], [4,5,6]])\n",
    "y = np.array([[4,5,6], [1,2,3]])\n",
    "np.cross(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### cumulative product \n",
    "Return the cumulative product of elements along a given axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 6], dtype=int32)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1,2,3])\n",
    "np.cumprod(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.,   2.,   6.,  24., 120., 720.])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "np.cumprod(a, dtype=float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### numpy.cumsum\n",
    "Return the cumulative sum of the elements along a given axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  3,  6, 10, 15, 21], dtype=int32)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1,2,3], [4,5,6]])\n",
    "np.cumsum(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  3,  6, 10, 15, 21], dtype=int32)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.cumsum(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [5, 7, 9]], dtype=int32)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.cumsum(a,axis=0) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### numpy.diff\n",
    "numpy.diff(a, n=1, axis=-1, prepend=<no value>, append=<no value>)\n",
    "    \n",
    "Calculate the n-th discrete difference along the given axis.\n",
    "\n",
    "The first difference is given by out[n] = a[n+1] - a[n] along the given axis, higher differences are calculated by using diff recursively.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([255], dtype=uint8)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u8_arr = np.array([1, 0], dtype=np.uint8)\n",
    "np.diff(u8_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3, -7])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([1, 2, 4, 7, 0])\n",
    "np.diff(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dot product\n",
    "Dot product of two arrays. Specifically,\n",
    "\n",
    "If both a and b are 1-D arrays, it is inner product of vectors (without complex conjugation).\n",
    "\n",
    "If both a and b are 2-D arrays, it is matrix multiplication, but using matmul or a @ b is preferred.\n",
    "\n",
    "If either a or b is 0-D (scalar), it is equivalent to multiply and using numpy.multiply(a, b) or a * b is preferred.\n",
    "\n",
    "If a is an N-D array and b is a 1-D array, it is a sum product over the last axis of a and b.\n",
    "\n",
    "If a is an N-D array and b is an M-D array (where M>=2), it is a sum product over the last axis of a and the second-to-last axis of b:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4, 1],\n",
       "       [2, 2]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [[1, 0], [0, 1]]\n",
    "b = [[4, 1], [2, 2]]\n",
    "np.dot(a,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### numpy.floor\n",
    "Return the floor of the input, element-wise.\n",
    "\n",
    "The floor of the scalar x is the largest integer i, such that i <= x. It is often denoted as \\lfloor x \\rfloor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2., -2., -1.,  0.,  1.,  1.,  2.])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])\n",
    "np.floor(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### numpy.inner\n",
    "Inner product of two arrays.\n",
    "\n",
    "Ordinary inner product of vectors for 1-D arrays (without complex conjugation), in higher dimensions a sum product over the last axes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1,2,3])\n",
    "b = np.array([0,1,0])\n",
    "np.inner(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 14,  38,  62],\n",
       "       [ 86, 110, 134]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(24).reshape((2,3,4))\n",
    ">>> b = np.arange(4)\n",
    ">>> np.inner(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 0, 4, 6, 5, 3, 1], dtype=int64)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#### numpy.lexsort\n",
    "a = [1,5,1,4,3,4,4] # First column\n",
    "b = [9,4,0,4,0,2,1] # Second column\n",
    "ind = np.lexsort((b,a)) # Sort by a, then by b\n",
    "ind"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### numpy.maximum\n",
    "Element-wise maximum of array elements.\n",
    "\n",
    "Compare two arrays and returns a new array containing the element-wise maxima. If one of the elements being compared is a NaN, then that element is returned. If both elements are NaNs then the first is returned. The latter distinction is important for complex NaNs, which are defined as at least one of the real or imaginary parts being a NaN. The net effect is that NaNs are propagated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 5, 4])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.maximum([2, 3, 4], [1, 5, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1. , 2. ],\n",
       "       [0.5, 2. ]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.maximum(np.eye(2), [0.5, 2]) # broadcasting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### numpy.mean\n",
    "Compute the arithmetic mean along the specified axis.\n",
    "\n",
    "\n",
    "Returns the average of the array elements. The average is taken over the flattened array by default, otherwise over the specified axis. float64 intermediate and return values are used for integer inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[1, 2], [3, 4]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### numpy.median\n",
    "Compute the median along the specified axis.\n",
    "\n",
    "Returns the median of the array elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.5"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[10, 7, 4], [3, 2, 1]])\n",
    "np.median(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6.5, 4.5, 2.5])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.median(a, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7., 2.])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.median(a, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### numpy.minimum\n",
    "\n",
    "Element-wise minimum of array elements.\n",
    "\n",
    "Compare two arrays and returns a new array containing the element-wise minima. If one of the elements being compared is a NaN, then that element is returned. If both elements are NaNs then the first is returned. The latter distinction is important for complex NaNs, which are defined as at least one of the real or imaginary parts being a NaN. The net effect is that NaNs are propagated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 2])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.minimum([2, 3, 4], [1, 5, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.5, 0. ],\n",
       "       [0. , 1. ]])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.minimum(np.eye(2), [0.5, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### numpy.nonzero\n",
    "Return the indices of the elements that are non-zero.\n",
    "\n",
    "Returns a tuple of arrays, one for each dimension of a, containing the indices of the non-zero elements in that dimension. The values in a are always tested and returned in row-major, C-style order. The corresponding non-zero values can be obtained with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 1, 2, 2], dtype=int64), array([0, 1, 0, 1], dtype=int64))"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]])\n",
    "np.nonzero(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### numpy.outer\n",
    "\n",
    "Compute the outer product of two vectors.\n",
    "\n",
    "Given two vectors, a = [a0, a1, ..., aM] and b = [b0, b1, ..., bN], the outer product [1] is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-2., -1.,  0.,  1.,  2.],\n",
       "       [-2., -1.,  0.,  1.,  2.],\n",
       "       [-2., -1.,  0.,  1.,  2.],\n",
       "       [-2., -1.,  0.,  1.,  2.],\n",
       "       [-2., -1.,  0.,  1.,  2.]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5))\n",
    "rl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### numpy.prod\n",
    "\n",
    "Return the product of array elements over a given axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([536870910, 536870910, 536870910, 536870910])\n",
    "np.prod(x) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([1, 2, 3], dtype=np.uint8)\n",
    "np.prod(x).dtype == np.uint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### sort\n",
    "Return a sorted copy of an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4],\n",
       "       [1, 3]])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> a = np.array([[1,4],[3,1]])\n",
    ">>> np.sort(a)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### standard deviation\n",
    "Compute the standard deviation along the specified axis.\n",
    "\n",
    "Returns the standard deviation, a measure of the spread of a distribution, of the array elements. The standard deviation is computed for the flattened array by default, otherwise over the specified axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.118033988749895"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[1, 2], [3, 4]])\n",
    ">>> np.std(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1.])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.std(a, axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### numpy.sum\n",
    "Sum of array elements over a given axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum([0.5, 1.5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### numpy.trace\n",
    "\n",
    "Return the sum along diagonals of the array.\n",
    "\n",
    "If a is 2-D, the sum along its diagonal with the given offset is returned, i.e., the sum of elements a[i,i+offset] for all i.\n",
    "\n",
    "If a has more than two dimensions, then the axes specified by axis1 and axis2 are used to determine the 2-D sub-arrays whose traces are returned. The shape of the resulting array is the same as that of a with axis1 and axis2 removed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.trace(np.eye(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### numpy.transpose\n",
    "\n",
    "Permute the dimensions of an array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [2, 3]])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(4).reshape((2,2))\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 2],\n",
       "       [1, 3]])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.transpose(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### numpy.var\n",
    "\n",
    "Compute the variance along the specified axis.\n",
    "\n",
    "Returns the variance of the array elements, a measure of the spread of a distribution. The variance is computed for the flattened array by default, otherwise over the specified axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.25 \n",
      "\n",
      "[1. 1.] \n",
      "\n",
      "[0.25 0.25] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1, 2], [3, 4]])\n",
    "print(np.var(a),\"\\n\")\n",
    "print(np.var(a, axis=0),\"\\n\")\n",
    "\n",
    "print(np.var(a, axis=1),\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### numpy.vdot(a, b)\n",
    "Return the dot product of two vectors.\n",
    "\n",
    "The vdot(a, b) function handles complex numbers differently than dot(a, b). If the first argument is complex the complex conjugate of the first argument is used for the calculation of the dot product.\n",
    "\n",
    "Note that vdot handles multidimensional arrays differently than dot: it does not perform a matrix product, but flattens input arguments to 1-D vectors first. Consequently, it should only be used for vectors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(70-8j)"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1+2j,3+4j])\n",
    "b = np.array([5+6j,7+8j])\n",
    "np.vdot(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### numpy.vectorize\n",
    "\n",
    "Generalized function class.\n",
    "\n",
    "Define a vectorized function which takes a nested sequence of objects or numpy arrays as inputs and returns a single numpy array or a tuple of numpy arrays. The vectorized function evaluates pyfunc over successive tuples of the input arrays like the python map function, except it uses the broadcasting rules of numpy.\n",
    "\n",
    "The data type of the output of vectorized is determined by calling the function with the first element of the input. This can be avoided by specifying the otypes argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myfunc(a, b):\n",
    "...     \"Return a-b if a>b, otherwise return a+b\"\n",
    "...     if a > b:\n",
    "...         return a - b\n",
    "...     else:\n",
    "...         return a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Return a-b if a>b, otherwise return a+b\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([3, 4, 1, 2])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vfunc = np.vectorize(myfunc)\n",
    "print(vfunc.__doc__)\n",
    "vfunc([1, 2, 3, 4], 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### numpy.where\n",
    "numpy.where(condition[, x, y])\n",
    "\n",
    "\n",
    "Return elements chosen from x or y depending on condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4, 50, 60, 70, 80, 90])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(10)\n",
    "np.where(a < 5, a, 10*a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}