Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                                        Installing Numpy Library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: numpy in c:\\users\\hp\\anaconda3\\lib\\site-packages (1.16.5)\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "pip install numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                                        Numpy Basic Array Manipulations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                                   Multidimenional array objects (nd array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0.],\n",
       "       [0., 0.]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# An array containing zeros\n",
    "\n",
    "np.zeros((2,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1.],\n",
       "       [1., 1.]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# An array containing ones\n",
    "\n",
    "np.ones((2,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1.],\n",
       "       [1., 1.]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A random array ( not always zeros, can be any number)\n",
    "\n",
    "np.empty((2,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Ali' '5' '34' '2']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Converting a python list into a numpy array\n",
    "\n",
    "a=[\"Ali\",5,34,2]\n",
    "b=np.array(a)\n",
    "print(b)\n",
    "\n",
    "\"\"\" Now checking type\"\"\"\n",
    "\n",
    "type(b)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  6, 11, 16, 21, 26, 31, 36, 41, 46, 51, 56, 61, 66, 71, 76, 81,\n",
       "       86, 91, 96])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating an array in a given range (similar to python k loop ki range)\n",
    "\n",
    "\"\"\"1st argument is the starting point, 2nd arg is ending point & 3rd arg is the num of steps \"\"\"\n",
    "\n",
    "np.arange(1,100,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 10)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Gives the shape of an array (size of array along each dimemsion)\n",
    "\n",
    "x=np.ones((10,10))\n",
    "x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[[1., 1., 1., 1., 1.],\n",
       "         [1., 1., 1., 1., 1.],\n",
       "         [1., 1., 1., 1., 1.],\n",
       "         [1., 1., 1., 1., 1.],\n",
       "         [1., 1., 1., 1., 1.]],\n",
       "\n",
       "        [[1., 1., 1., 1., 1.],\n",
       "         [1., 1., 1., 1., 1.],\n",
       "         [1., 1., 1., 1., 1.],\n",
       "         [1., 1., 1., 1., 1.],\n",
       "         [1., 1., 1., 1., 1.]]],\n",
       "\n",
       "\n",
       "       [[[1., 1., 1., 1., 1.],\n",
       "         [1., 1., 1., 1., 1.],\n",
       "         [1., 1., 1., 1., 1.],\n",
       "         [1., 1., 1., 1., 1.],\n",
       "         [1., 1., 1., 1., 1.]],\n",
       "\n",
       "        [[1., 1., 1., 1., 1.],\n",
       "         [1., 1., 1., 1., 1.],\n",
       "         [1., 1., 1., 1., 1.],\n",
       "         [1., 1., 1., 1., 1.],\n",
       "         [1., 1., 1., 1., 1.]]]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Changes the dimesnsion into n-dimension where n is the number of dimension you want\n",
    "\n",
    "\"\"\"The size or dimension should remain same , For Eg: In x, the shape was 10x10 which is equal to 100.\n",
    "    If you reshape x, the product after reshape should be 100 or it won't work\"\"\"\n",
    "\n",
    "x=np.ones((10,10))\n",
    "x.reshape((2,2,5,5))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Checking data type\n",
    "\n",
    "y=np.empty((2,2))\n",
    "y\n",
    "y.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1.19419859e-311 1.19419618e-311 1.27276404e+232 1.14448054e+243]\n",
      "  [4.45547991e+252 2.31633990e-152 1.21697543e-152 3.17247824e+180]\n",
      "  [2.90892112e-014 7.20191272e+159 2.58636056e+161 2.19527311e-152]\n",
      "  [1.69337237e-152 1.06098609e-153 7.35419734e+223 7.50187034e+247]\n",
      "  [1.27734650e-152 1.72977319e+156 7.71463020e+199 6.99405059e-009]]\n",
      "\n",
      " [[1.10982361e+171 3.48989969e-086 1.05774136e-153 7.18988929e+140]\n",
      "  [1.03063392e-113 7.27135128e-043 8.24227377e-072 5.40223320e-062]\n",
      "  [2.25563599e-153 2.86643569e+161 1.05089607e-153 4.55071999e+198]\n",
      "  [1.18125339e-076 1.05089597e-153 1.95600843e-109 1.35717430e+131]\n",
      "  [6.01347002e-154 3.84568617e-086 2.31738989e-052 2.52822123e-052]]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Gives the dimension\n",
    "\n",
    "x=np.empty((2,5,4))\n",
    "print(x)\n",
    "\n",
    "\"\"\"The dimension of x is\"\"\"\n",
    "\n",
    "x.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                                      \n",
    "                                      Arithmetic Operation with nd arrays "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.83184635,  0.10785245,  0.86197029,  0.61401464, -0.06247483,\n",
       "        2.4813388 , -1.17423403, -0.51788369, -1.32868587, -0.90499644])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating a random array\n",
    "a=np.random.randn(10)\n",
    "a\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.12859568, -2.93554965,  2.08402768, -0.32141558, -0.26348386,\n",
       "       -0.08031245, -0.43112405,  0.31401596, -0.80769561,  1.62762448])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b=np.random.randn(10)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.29674933, -2.8276972 ,  2.94599797,  0.29259906, -0.32595869,\n",
       "        2.40102635, -1.60535808, -0.20386773, -2.13638147,  0.72262804])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"All the operations are index to index\"\"\"\n",
    "\n",
    "\n",
    "# Adding two arrays\n",
    "\n",
    "a+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.96044203,  3.0434021 , -1.22205739,  0.93543023,  0.20100903,\n",
       "        2.56165124, -0.74310998, -0.83189965, -0.52099026, -2.53262091])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sbbtracting them\n",
    "\n",
    "a-b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.9388182 , -0.31660622,  1.79636994, -0.19735387,  0.01646111,\n",
       "       -0.1992824 ,  0.50624053, -0.16262374,  1.07317374, -1.47299435])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiplying them\n",
    "\n",
    "a*b\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ -0.7370632 ,  -0.03674012,   0.41360789,  -1.91034499,\n",
       "         0.23711065, -30.89606674,   2.72365697,  -1.64922729,\n",
       "         1.64503292,  -0.55602287])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# dividing them\n",
    "a/b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False, False, False, False, False, False,\n",
       "       False])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Comparison of arrays\n",
    "\n",
    "a==b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True,  True, False,  True, False, False, False,\n",
       "       False])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Checking if thethe array is greater than zero\n",
    "\n",
    "\"\"\"It will return the answer of each index in array in boolean form\"\"\"\n",
    "\n",
    "a>0\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.83184635, 0.10785245, 0.86197029, 0.61401464, 2.4813388 ])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# fetching the values greater than zero\n",
    "\n",
    "\"\"\"We pass the whole statement as an index in the same array\"\"\"\n",
    "\n",
    "a[a>0]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                                               Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# positive index\n",
    "\n",
    "x=np.array([1,2,3,4,5])\n",
    "x\n",
    "\n",
    "\"\"\" The indexing is same as that of simple python list. The only difference \n",
    "    is that the indices here are of a numpy array and not of a list \"\"\"\n",
    "\n",
    "\n",
    "x[1]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# negative index\n",
    "\n",
    "x[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Boolean indexing\n",
    "\n",
    "\"\"\" This is to extract out elements by giving conditions in index \"\"\"\n",
    "\n",
    "x[x>2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Fancy indexing\n",
    "\n",
    "\"\"\"We passed a list as an index. Each index in this list gives the output that \n",
    "    corresponds to the value of that index in the original array\"\"\"\n",
    "\n",
    "x[[2,3,4]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                                                    Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.66970714, -0.52832905,  0.32476438, -0.88512576,  0.9875199 ],\n",
       "       [ 0.0731222 , -0.17189528,  1.01323033, -0.27190618,  0.68662395],\n",
       "       [-0.6263941 , -0.428474  ,  0.76287729,  0.3804363 ,  0.27598567],\n",
       "       [-0.72455347,  0.14688114, -0.90776396,  0.01344175, -1.92117596],\n",
       "       [ 2.02950599,  0.69255954, -0.4136474 ,  0.0031128 , -0.79430052]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Making a random array of order 5x5 for slicing\n",
    "\n",
    "a=np.random.randn(5,5)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.66970714, -0.52832905,  0.32476438, -0.88512576,  0.9875199 ])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing of rows\n",
    "\n",
    "\"\"\"The slicing is same as of normal python string or list.\n",
    "    It is slicing of rows if we consider this array as a matrix.\"\"\"\n",
    "\n",
    "\"\"\" This gives first row\"\"\"\n",
    "    \n",
    "a[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.52832905,  0.32476438, -0.88512576],\n",
       "       [-0.17189528,  1.01323033, -0.27190618],\n",
       "       [-0.428474  ,  0.76287729,  0.3804363 ],\n",
       "       [ 0.14688114, -0.90776396,  0.01344175],\n",
       "       [ 0.69255954, -0.4136474 ,  0.0031128 ]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# slicing of coloumns\n",
    "\n",
    "\"\"\" This gives values from coloumn 2 to coloumn 5\"\"\"\n",
    "\n",
    "a[::,1:4] \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9875199036333739"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# SLicing of single coloumn w.r.t it's row\n",
    "\n",
    "'''This gives value of 5th coloumn in 1st row'''\n",
    "\n",
    "a[0][4]   \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original matrix:\n",
      "\n",
      "[[1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1.]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1., 1.],\n",
       "       [1., 0., 0., 0., 1.],\n",
       "       [1., 0., 0., 0., 1.],\n",
       "       [1., 0., 0., 0., 1.],\n",
       "       [1., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating a square with ones as borders and zeros as center\n",
    "\n",
    "s=np.ones((5,5))\n",
    "\n",
    "print(\"Original matrix:\")\n",
    "print()\n",
    "print(s)\n",
    "\n",
    "\"\"\"The first slicing represents rows whereas slicing after comma represents coloumns\"\"\"\n",
    "\n",
    "s[1:4,1:4]=0\n",
    "s\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 1. 0. 1. 0. 1. 0. 1.]\n",
      " [1. 0. 1. 0. 1. 0. 1. 0.]\n",
      " [0. 1. 0. 1. 0. 1. 0. 1.]\n",
      " [1. 0. 1. 0. 1. 0. 1. 0.]\n",
      " [0. 1. 0. 1. 0. 1. 0. 1.]\n",
      " [1. 0. 1. 0. 1. 0. 1. 0.]\n",
      " [0. 1. 0. 1. 0. 1. 0. 1.]\n",
      " [1. 0. 1. 0. 1. 0. 1. 0.]]\n"
     ]
    }
   ],
   "source": [
    "# Creating a chess board\n",
    "\n",
    "\"\"\"This is done in 2 steps. In step 1 the odd rows and coloumns were made 0 using steps.\n",
    "    In step 2, the even rows and coloumns were made 0 using steps\"\"\"\n",
    "\n",
    "w=np.ones((8,8))\n",
    "w\n",
    "\n",
    "\"\"\" Step 1 \"\"\"\n",
    "w[0:9:2,0:9:2]=0\n",
    "chessBoard=w\n",
    "\n",
    "\"\"\" Step 2 \"\"\"\n",
    "\n",
    "chessBoard[1:9:2,1:9:2]=0\n",
    "print(chessBoard)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                                        Element-wise Array Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  4,  6, 44])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=np.array([1,2,4,6,44])\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([    1,     8,    64,   216, 85184], dtype=int32)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Gives exponent\n",
    "\n",
    "\"\"\" All the functions gives element-wise results \"\"\"\n",
    "\n",
    "np.power(x,3) # Gives cube of each element in array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.        , 1.41421356, 2.        , 2.44948974, 6.63324958])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Getting square root\n",
    "\n",
    "np.sqrt(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   1,    4,   16,   36, 1936], dtype=int32)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Gives square\n",
    "\n",
    "np.square(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.84147098,  0.90929743, -0.7568025 , -0.2794155 ,  0.01770193])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Gives sine angle of each element\n",
    "\n",
    "np.sin(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.54030231, -0.41614684, -0.65364362,  0.96017029,  0.99984331])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Gives cosine angle of each element\n",
    "\n",
    "np.cos(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.55740772, -2.18503986,  1.15782128, -0.29100619,  0.0177047 ])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Gives tangent angle of each element\n",
    "\n",
    "np.tan(x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                                        Where Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Not Ok', 'Not Ok', 'Ok', 'Ok'], dtype='<U6')"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\" The format of where function goes like this,\n",
    "    where(condition,action(if True),action otherwise) \"\"\"\n",
    "\n",
    "# It kind of works like an if condition where the condition is 1st argument with automatic if\n",
    "# and 2nd argument is the fulfilment of the condition if true and 3rd argument is the else part.\n",
    "\n",
    "salary=np.array([0,-1,50000,44000])\n",
    "np.where(salary<=0,\"Not Ok\",\"Ok\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                                    Mathematical & Statistical Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23.0"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Getting mean\n",
    "\n",
    "i=np.array([1,82,3,6])\n",
    "np.mean(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, 83, 86, 92], dtype=int32)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Gives commulative sum\n",
    "\n",
    "\"\"\"\" Each element afterwards is equal to the sum of its previous elements \"\"\"\n",
    "\n",
    "np.cumsum(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   1,   82,  246, 1476], dtype=int32)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Gives commulative product\n",
    "\n",
    "\"\"\"\" Each element afterwards is equal to the product of its previous elements \"\"\"\n",
    "\n",
    "np.cumprod(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True, False, False])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Checking condition for each index\n",
    "\n",
    "x=i>6\n",
    "x\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "92"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Gives sum of all elements\n",
    "\n",
    "np.sum(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Checks if any element is True\n",
    "\n",
    "np.any(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Checks if all element are True\n",
    "\n",
    "np.all(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  3,  6, 82])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Sorts the array\n",
    "\n",
    "np.sort(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  3,  6, 82])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Gives unique elements\n",
    "\n",
    "np.unique(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                                                File Input Output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Saving an array in a file\n",
    "\n",
    "arr1=[1,2,3,4]\n",
    "arr2=[2,3,6,8,9]\n",
    "arr3=[3,4,66,2,1]\n",
    "np.save(\"singleSave.npy\",arr2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 6, 8, 9])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# loading a saved file\n",
    "\n",
    "\"\"\"This gives the result in a dictionary. All the arrays are stored as keys and \n",
    "    can be fetched in the same manner as a key of dictionary is fetched \"\"\"\n",
    "\n",
    "np.load(\"singleSave.npy\")\n",
    "\n",
    "#    Since, it's a single key (array) here, therefore, the result is given directly. It \n",
    "#    would have been fetched by a dictionary key fetching method otherwise !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<numpy.lib.npyio.NpzFile object at 0x00000232C6F89648>\n"
     ]
    }
   ],
   "source": [
    "# saving multiple arrays in a single file \n",
    "\n",
    "np.savez(\"MultiSave\",arr1,arr2,arr3)\n",
    "myDict=np.load(\"MultiSave.npz\")\n",
    "print(myDict)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                                            Linear Algebra Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x= \n",
      " [[-0.19925803 -0.43384444  1.34521363]\n",
      " [ 1.14542225 -0.72850644 -1.35022054]\n",
      " [-0.18554395 -0.51620002 -0.16641152]]\n",
      "y= \n",
      " [[ 1.51300859 -0.53703275  1.82563984]\n",
      " [ 0.70288797 -1.1589389  -0.34444559]\n",
      " [-0.28391285 -0.8868553  -0.47505534]]\n"
     ]
    }
   ],
   "source": [
    "x=np.random.randn(3,3)\n",
    "y=np.random.randn(3,3)\n",
    "print(\"x=\",\"\\n\",x)\n",
    "print(\"y=\",\"\\n\",y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.98834658, -0.58320254, -0.85338851],\n",
       "       [ 1.60432025,  1.42661544,  2.9834888 ],\n",
       "       [-0.596314  ,  0.8454704 , -0.08187893]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Dot product of 2 matrices\n",
    "\n",
    "np.dot(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.19925803,  1.14542225, -0.18554395],\n",
       "       [-0.43384444, -0.72850644, -0.51620002],\n",
       "       [ 1.34521363, -1.35022054, -0.16641152]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Transpose of a matrix\n",
    "\n",
    "np.transpose(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.094175994510488"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Trace of a matrix\n",
    "\n",
    "np.trace(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.19925803, -0.72850644, -0.16641152])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# diagonal of a matrix\n",
    "\n",
    "np.diag(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eigen values are: \n",
      " [ 0.14743877+0.85846457j  0.14743877-0.85846457j -1.38905354+0.j        ]\n",
      "\n",
      "Eigen vectors are: \n",
      " [[ 0.74334274+0.j          0.74334274-0.j         -0.08873812+0.j        ]\n",
      " [ 0.09260394-0.5490341j   0.09260394+0.5490341j   0.92237665+0.j        ]\n",
      " [ 0.22144457+0.29730446j  0.22144457-0.29730446j  0.37596125+0.j        ]]\n"
     ]
    }
   ],
   "source": [
    "# Eigen values and correseponding vectors of  matrix\n",
    "\n",
    "from numpy import linalg as LA\n",
    "values,vectors=LA.eig(x)\n",
    "print(\"Eigen values are:\",\"\\n\",values)\n",
    "print()\n",
    "print(\"Eigen vectors are:\",\"\\n\",vectors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.54631938,  0.72740738, -1.48573919],\n",
       "       [-0.41858567, -0.26830056, -1.20678076],\n",
       "       [ 0.68930127,  0.02121675, -0.6092717 ]])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Gives inverse of a matrix\n",
    "\n",
    "LA.inv(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Gives rank of  a matrix\n",
    "\n",
    "LA.matrix_rank(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0538743846788503"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Gives determinant of a matrix\n",
    "\n",
    "LA.det(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.19925803,  1.14542225, -0.18554395],\n",
       "       [-0.43384444, -0.72850644, -0.51620002],\n",
       "       [ 1.34521363, -1.35022054, -0.16641152]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Gives adjoint of a matrix\n",
    "\n",
    "np.matrix.getH(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.19925803, -0.43384444,  1.34521363],\n",
       "       [ 1.14542225, -0.72850644, -1.35022054],\n",
       "       [-0.18554395, -0.51620002, -0.16641152]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Gives conjugate of a matrix\n",
    "\n",
    "np.conjugate(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                                                Pseudo Random Numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To initialize\n",
    "\n",
    "np.random.seed(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.69052570e+00, -4.65937371e-01,  3.28201637e-02],\n",
       "       [ 4.07516283e-01, -7.88923029e-01,  2.06557291e-03],\n",
       "       [-8.90385858e-04, -1.75472431e+00,  1.01765801e+00]])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Normal distributuion\n",
    "\n",
    "np.random.normal(size=(3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.38094113, 0.06593635, 0.2881456 ],\n",
       "       [0.90959353, 0.21338535, 0.45212396],\n",
       "       [0.93120602, 0.02489923, 0.60054892]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Uniform distributuion\n",
    "\n",
    "np.random.uniform(size=(3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6.35244905, 5.19258072])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Chi Square distributuion\n",
    "\n",
    "np.random.chisquare((5,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.14291176, 0.74110411])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Gamma distributuion\n",
    "\n",
    "np.random.gamma((1,1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                                     Numpy Advanced Array Manipulations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                                            Reshape Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: \n",
      " [[-0.17953522  1.9086429   0.23986947 -1.06344985 -0.21228429]\n",
      " [ 0.92569535 -1.7279359   1.53067224 -0.23343633  0.29719528]\n",
      " [ 0.99286434 -0.93597859 -0.95960851 -0.19904275 -0.61285757]\n",
      " [-1.25337305 -0.3222009   2.71396693  1.62985742  1.13361691]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[[-0.17953522,  1.9086429 ,  0.23986947, -1.06344985,\n",
       "         -0.21228429],\n",
       "        [ 0.92569535, -1.7279359 ,  1.53067224, -0.23343633,\n",
       "          0.29719528]],\n",
       "\n",
       "       [[ 0.99286434, -0.93597859, -0.95960851, -0.19904275,\n",
       "         -0.61285757],\n",
       "        [-1.25337305, -0.3222009 ,  2.71396693,  1.62985742,\n",
       "          1.13361691]]])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reshape basically changes the order of elements in matrix by manipulating axes and dimensions.\n",
    "# The count of elements and elements themselves remains same. It is simply change of way a matrix \n",
    "# is written by manipulation of dimensions.\n",
    "\n",
    "a=np.random.randn(4,5)\n",
    "print(\"a:\",\"\\n\",a)\n",
    "\n",
    "\"\"\"The product of dimenssions should be equal when reshaping\"\"\"\n",
    "\n",
    "a.reshape(2,2,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[-0.17953522,  1.9086429 ,  0.23986947, -1.06344985,\n",
       "         -0.21228429],\n",
       "        [ 0.99286434, -0.93597859, -0.95960851, -0.19904275,\n",
       "         -0.61285757]],\n",
       "\n",
       "       [[ 0.92569535, -1.7279359 ,  1.53067224, -0.23343633,\n",
       "          0.29719528],\n",
       "        [-1.25337305, -0.3222009 ,  2.71396693,  1.62985742,\n",
       "          1.13361691]]])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Coloumn major order or Fortran Order\n",
    "\n",
    "a.reshape((2,2,5),order=\"F\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[-0.17953522,  1.9086429 ,  0.23986947, -1.06344985,\n",
       "         -0.21228429],\n",
       "        [ 0.92569535, -1.7279359 ,  1.53067224, -0.23343633,\n",
       "          0.29719528]],\n",
       "\n",
       "       [[ 0.99286434, -0.93597859, -0.95960851, -0.19904275,\n",
       "         -0.61285757],\n",
       "        [-1.25337305, -0.3222009 ,  2.71396693,  1.62985742,\n",
       "          1.13361691]]])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Row major order or C Order\n",
    "\n",
    "\n",
    "a.reshape((2,2,5),order=\"C\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.17953522  1.9086429   0.23986947 -1.06344985 -0.21228429  0.92569535\n",
      " -1.7279359   1.53067224 -0.23343633  0.29719528  0.99286434 -0.93597859\n",
      " -0.95960851 -0.19904275 -0.61285757 -1.25337305 -0.3222009   2.71396693\n",
      "  1.62985742  1.13361691]\n",
      "\n",
      "[-0.17953522  1.9086429   0.23986947 -1.06344985 -0.21228429  0.92569535\n",
      " -1.7279359   1.53067224 -0.23343633  0.29719528  0.99286434 -0.93597859\n",
      " -0.95960851 -0.19904275 -0.61285757 -1.25337305 -0.3222009   2.71396693\n",
      "  1.62985742  1.13361691]\n"
     ]
    }
   ],
   "source": [
    "# Converting in 1 dimension\n",
    "\n",
    "x=a.ravel()\n",
    "print(x)\n",
    "print()\n",
    "y=a.flatten()\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.17953522,  1.9086429 ],\n",
       "       [ 0.23986947, -1.06344985],\n",
       "       [-0.21228429,  0.92569535],\n",
       "       [-1.7279359 ,  1.53067224],\n",
       "       [-0.23343633,  0.29719528],\n",
       "       [ 0.99286434, -0.93597859],\n",
       "       [-0.95960851, -0.19904275],\n",
       "       [-0.61285757, -1.25337305],\n",
       "       [-0.3222009 ,  2.71396693],\n",
       "       [ 1.62985742,  1.13361691]])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\" -1 leaves it upto numpy to complete the rest of the dimension \"\"\"\n",
    "\n",
    "a.reshape(10,-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                                             Concatenate Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3],\n",
       "       [ 2,  4,  6],\n",
       "       [11, 12, 13],\n",
       "       [12, 14, 16]])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Row-wise concatenation\n",
    "\n",
    "x=np.array(([1,2,3],[2,4,6]))\n",
    "y=np.array(([11,12,13],[12,14,16]))\n",
    "\n",
    "\"\"\" It requires an axis. It can either be 0 or 1. 0 represents row-wise concatenation.The number \n",
    "    of  rows increases whereas the number of coloumns remains same in row-wise concatenation \"\"\"\n",
    "\n",
    "np.concatenate((x,y),axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3, 11, 12, 13],\n",
       "       [ 2,  4,  6, 12, 14, 16]])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Coloumn-wise concatenation\n",
    "\n",
    "x=np.array(([1,2,3],[2,4,6]))\n",
    "y=np.array(([11,12,13],[12,14,16]))\n",
    "\n",
    "\"\"\" It requires an axis. It can either be 0 or 1. 1 represents coloumn-wise concatenation.The number \n",
    "    of  coloumns increases whereas the number of rows remains same in coloumn-wise concatenation \"\"\"\n",
    "\n",
    "np.concatenate((x,y),axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3],\n",
       "       [ 2,  4,  6],\n",
       "       [11, 12, 13],\n",
       "       [12, 14, 16]])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Default Row-wise concatenation\n",
    "\n",
    "np.vstack((x,y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3, 11, 12, 13],\n",
       "       [ 2,  4,  6, 12, 14, 16]])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Default Coloumn-wise concatenation\n",
    "\n",
    "np.hstack((x,y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                                               Split Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([1, 2]), array([3, 2, 4]), array([6, 6]), array([9, 0, 5, 3])]"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Splitting of an array into n arrays\n",
    "\n",
    "x=np.array(([1,2,3,2,4,6,6,9,0,5,3]))\n",
    "\n",
    "\"\"\" The first argument is of the array to be split and second is for the positions on which split occurs\"\"\"\n",
    "\n",
    "np.split(x,[2,5,7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[1, 2],\n",
       "        [2, 4]]), array([[ 3,  5,  7],\n",
       "        [ 6,  8, 10]]), array([[ 9,  3],\n",
       "        [12, 14]])]"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Coloumn-wise split\n",
    "\n",
    "x=np.array(([1,2,3,5,7,9,3],\n",
    "            [2,4,6,8,10,12,14]))\n",
    "\n",
    "\"\"\" It is a coloumn-wise split. First split of both arrays in the tuple occurs at \n",
    "    coloumn 2 and second split occurs at coloumn 5 for both arrays in the tuple. \n",
    "    The remaining elements of a single array is splitted in an array for each \n",
    "    individual array in the tuple \"\"\"\n",
    "\n",
    "np.split(x,[2,5],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[ 1,  2,  3,  5,  7,  9,  3],\n",
       "        [ 2,  4,  6,  8, 10, 12, 14]]),\n",
       " array([], shape=(0, 7), dtype=int32),\n",
       " array([], shape=(0, 7), dtype=int32)]"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Row-wise split\n",
    "\n",
    "x=np.array(([1,2,3,5,7,9,3],\n",
    "            [2,4,6,8,10,12,14]))\n",
    "\n",
    "\"\"\" It is a row-wise split. First split of both arrays in the tuple occurs at row 2\n",
    "    and second split occurs at row 5 for both arrays in the tuple. The remaining \n",
    "    elements of every array is splitted in individual arrays for each initial array\"\"\"\n",
    "\n",
    "np.split(x,[2,5],axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[ 1,  2,  3,  5,  7,  9,  3],\n",
       "        [ 2,  4,  6,  8, 10, 12, 14]]),\n",
       " array([], shape=(0, 7), dtype=int32),\n",
       " array([], shape=(0, 7), dtype=int32)]"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Default row-wise split\n",
    "\n",
    "np.vsplit(x,[2,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[1, 2],\n",
       "        [2, 4]]), array([[ 3,  5,  7],\n",
       "        [ 6,  8, 10]]), array([[ 9,  3],\n",
       "        [12, 14]])]"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Default coloumn-wise split\n",
    "\n",
    "np.hsplit(x,[2,5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                                                Repeat Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 5, 5, 5, 5, 7, 7, 7, 7, 9, 9,\n",
       "       9, 9, 3, 3, 3, 3])"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Repetition of each element in same array for n number of times\n",
    "\n",
    "x=np.array(([1,2,3,5,7,9,3]))\n",
    "\n",
    "\"\"\" 1st argument represents the array to be repeated whereas 2nd argument takes\n",
    "    the number of times each element should be repeated as a parameter  \"\"\"\n",
    "\n",
    "np.repeat(x,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "                                            Tile Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 5, 7, 9, 3, 1, 2, 3, 5, 7, 9, 3, 1, 2, 3, 5, 7, 9, 3])"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating a copy of an array in same array as individual elements\n",
    "\n",
    "x=np.array(([1,2,3,5,7,9,3]))\n",
    "\n",
    "\"\"\" 1st argument represents the array to be copied whereas 2nd argument takes\n",
    "    the number of times the array should be copied as a parameter  \"\"\"\n",
    "\n",
    "np.tile(x,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}