numpy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "84f9d3d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9347fc24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 1])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1, 2, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f4ff324c",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([1.0, 2, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "64d29385",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "20ff756a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 1])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1.9, 2, 1], dtype='int')\n",
    "# converting float to int cuts numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c43eee9e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4d04c058",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "(2, 3)\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "print(a.ndim)\n",
    "print(a.shape) # 2 rows, 3 columns\n",
    "print(a.size) # the total size of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "b33758b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8 bytes\n",
      "48 bytes\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "48"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(a.itemsize, \"bytes\") # each element\n",
    "print(a.nbytes, \"bytes\")\n",
    "a.itemsize * a.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4a9f00c5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0.])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "35c4ab5b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(3, dtype=int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6fdbd666",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['hello there', 'hello there'],\n",
       "       ['hello there', 'hello there'],\n",
       "       ['hello there', 'hello there']], dtype='<U11')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.full((3, 2), 'hello there')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "09c064d4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0.],\n",
       "       [0., 1., 0., 0.],\n",
       "       [0., 0., 1., 0.],\n",
       "       [0., 0., 0., 1.]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.eye(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "565bcc09",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4.6711473e-310, 0.0000000e+000, 0.0000000e+000, 0.0000000e+000,\n",
       "       0.0000000e+000, 0.0000000e+000])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# uninitialized array\n",
    "np.empty(6) # the values will be whatever happens to already exist at that memory location"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "6b2ad56c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 5, 7, 9])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(1, 10, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "6c4f4ea7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  4.,  7., 10.])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(1, 10, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1ececb46",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.56387515, 0.48629152],\n",
       "       [0.35527803, 0.03589338],\n",
       "       [0.63377532, 0.08155511]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# uniform distribution\n",
    "np.random.random((3, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "cb2439df",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.25919643, -0.54533194, -0.70983446],\n",
       "       [-1.69215054,  0.44143079,  0.26699262],\n",
       "       [ 1.36153174,  0.98146249, -0.51735294]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# normal distribution\n",
    "# mean = 0, sd = 1\n",
    "np.random.normal(0, 1, (3, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "fe6b8e56",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.93285661 0.5125267  0.44907109 0.7221466 ]\n",
      " [0.23801342 0.39465657 0.31700118 0.40965993]\n",
      " [0.63567212 0.71763745 0.22555184 0.76927263]\n",
      " [0.57624998 0.03816234 0.2542776  0.66615823]]\n"
     ]
    }
   ],
   "source": [
    "a = np.random.rand(4, 4)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "ac86451f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7 2 8 5 5 7]\n",
      " [5 7 5 4 9 1]\n",
      " [5 7 2 8 9 1]\n",
      " [5 2 5 8 2 4]\n",
      " [3 7 1 3 3 6]\n",
      " [7 6 6 6 9 8]]\n"
     ]
    }
   ],
   "source": [
    "b = np.random.randint(1, 10, size=(6,6))\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae5d37f3",
   "metadata": {},
   "source": [
    "# Accessing elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "f8eae9b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7 2 8 5 5 7]\n",
      "8\n",
      "7\n",
      "[2 8 5 5 7]\n",
      "[7 2 8]\n",
      "[2 8 5 5]\n",
      "\n",
      "[7 8 5]\n",
      "[2 5 7]\n",
      "[7 5 5 8 2 7]\n",
      "\n",
      "[[7 2 8]\n",
      " [5 7 5]\n",
      " [5 7 2]]\n"
     ]
    }
   ],
   "source": [
    "print(b[0])\n",
    "print(b[0,2])\n",
    "print(b[0,-1])\n",
    "print(b[0,1:])\n",
    "print(b[0,:3]) \n",
    "print(b[0,1:5])\n",
    "print('')\n",
    "print(b[0,::2]) # every other element\n",
    "print(b[0,1::2]) # every other element, starting at index 1\n",
    "print(b[0,::-1]) # if step is negative, start and stop are swapped (a convenient way to reverse an array)\n",
    "print('')\n",
    "print(b[:3,:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "a491a390",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[6 8 4 4 5 1]\n",
      " [6 3 1 6 8 6]\n",
      " [8 3 8 9 3 5]\n",
      " [5 7 2 4 4 4]\n",
      " [7 6 3 6 5 6]\n",
      " [9 8 7 5 7 5]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([3, 6])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a[start:stop:step]\n",
    "a = np.random.randint(1, 10, size=(6, 6))\n",
    "print(a)\n",
    "\n",
    "a[1,1:5:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "2d8108c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  6   8   4   4   5   1]\n",
      " [  6   3 100   6   8   6]\n",
      " [  8   3   8   9   3   5]\n",
      " [  5   7   2   4   4   4]\n",
      " [  7   6   3   6   5   6]\n",
      " [  9   8   7   5   7   5]]\n"
     ]
    }
   ],
   "source": [
    "a[1,2] = 100\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "09c65059",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[  1   2   3]\n",
      "  [  4   5   6]]\n",
      "\n",
      " [[ 10  20  30]\n",
      "  [ 40  50  60]]\n",
      "\n",
      " [[100 200 300]\n",
      "  [400 500 600]]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[[1,2,3],[4,5,6]],[[10,20,30],[40,50,60]],[[100,200,300],[400,500,600]]])\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "1ddb5cb5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[2,0,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "20536ac2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[  1   2   0]\n",
      "  [  4   5   0]]\n",
      "\n",
      " [[ 10  20   0]\n",
      "  [ 40  50   0]]\n",
      "\n",
      " [[100 200   0]\n",
      "  [400 500   0]]]\n"
     ]
    }
   ],
   "source": [
    "a[:,:,2] = 0\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "c068fcf1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7 2 8 5 5 7]\n",
      " [5 7 5 4 9 1]\n",
      " [5 7 2 8 9 1]\n",
      " [5 2 5 8 2 4]\n",
      " [3 7 1 3 3 6]\n",
      " [7 6 6 6 9 8]]\n"
     ]
    }
   ],
   "source": [
    "# slices return views rather than copies of the array data\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "96f39182",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7 2 8]\n",
      " [5 7 5]\n",
      " [5 7 2]]\n"
     ]
    }
   ],
   "source": [
    "# extract subarray\n",
    "b_sub = b[:3,:3]\n",
    "print(b_sub)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "3b9cd1ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[100   2   8]\n",
      " [  5   7   5]\n",
      " [  5   7   2]]\n"
     ]
    }
   ],
   "source": [
    "# original array is changed\n",
    "b_sub[0,0] = 100\n",
    "print(b_sub)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "abd2dbf4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[100   2   8   5   5   7]\n",
      " [  5   7   5   4   9   1]\n",
      " [  5   7   2   8   9   1]\n",
      " [  5   2   5   8   2   4]\n",
      " [  3   7   1   3   3   6]\n",
      " [  7   6   6   6   9   8]]\n"
     ]
    }
   ],
   "source": [
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "80c75d98",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[100   2   8]\n",
      " [  5   7   5]\n",
      " [  5   7   2]]\n"
     ]
    }
   ],
   "source": [
    "b_sub_copy = b[:3,:3].copy()\n",
    "print(b_sub_copy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "9b2ec24e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1000    2    8]\n",
      " [   5    7    5]\n",
      " [   5    7    2]]\n"
     ]
    }
   ],
   "source": [
    "b_sub_copy[0,0] = 1000\n",
    "\n",
    "print(b_sub_copy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "13075b9b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[100   2   8]\n",
      " [  5   7   5]\n",
      " [  5   7   2]]\n"
     ]
    }
   ],
   "source": [
    "print(b_sub)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "f99c8aae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 5, 6])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# fancy indexing\n",
    "a = np.array([1, 2, 3, 4, 5, 6, 7])\n",
    "indexes = [0, 4, 5]\n",
    "a[indexes]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "5e5f9469",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[99  2  3  4 99 99  7]\n"
     ]
    }
   ],
   "source": [
    "a[indexes] = 99\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "447405e9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([100,   7,   2])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row_ind = np.array([0, 1, 2])\n",
    "col_ind = np.array([0, 1, 2])\n",
    "b_sub[row_ind, col_ind]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "2471a3fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 7]\n",
      "\n",
      "[[5 5]\n",
      " [5 2]]\n"
     ]
    }
   ],
   "source": [
    "# combining fancy indices with simple indices and slicing\n",
    "print(b_sub[2, [0, 1]])\n",
    "print('')\n",
    "print(b_sub[1:, [0, 2]])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d828bc6",
   "metadata": {},
   "source": [
    "# Reshaping, stacking, slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "099ffc8f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(1, 5)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "652497fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.reshape(2,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "c359443f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# concatenation\n",
    "a = np.array([1, 2, 3])\n",
    "b = np.array([4, 5, 6])\n",
    "\n",
    "np.concatenate([a, b])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "dcdf8114",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n",
      "\n",
      "[[ 1  2  3  7  8  9]\n",
      " [ 4  5  6 10 11 12]]\n"
     ]
    }
   ],
   "source": [
    "c = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "d = np.array([[7, 8, 9], [10, 11, 12]])\n",
    "\n",
    "print(np.concatenate([c, d]))\n",
    "print('')\n",
    "print(np.concatenate([c, d], axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "c7acaacf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10 10]\n",
      " [10 10]]\n",
      "\n",
      "[[2 2]]\n",
      "\n",
      "[[5]\n",
      " [5]]\n"
     ]
    }
   ],
   "source": [
    "a = np.full((2,2), 10)\n",
    "b = np.full((1,2), 2)\n",
    "c = np.full((2,1), 5)\n",
    "print(a)\n",
    "print('')\n",
    "print(b)\n",
    "print('')\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "60cebcc7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10 10]\n",
      " [10 10]\n",
      " [ 2  2]]\n",
      "\n",
      "[[10 10  5]\n",
      " [10 10  5]]\n"
     ]
    }
   ],
   "source": [
    "# for working with arrays of mixed dimensions\n",
    "\n",
    "print(np.vstack([a,b]))\n",
    "print('')\n",
    "print(np.hstack([a,c]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "3987d6d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3] [4 5] [6 7 8]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
    "x1, x2, x3 = np.split(a, [3,5])\n",
    "print(x1,x2,x3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "e14ab90f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# there is also hsplit and vsplit"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f05f8693",
   "metadata": {},
   "source": [
    "# Math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "28d989e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[10 20 30]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3])\n",
    "print(a)\n",
    "b = np.array([10, 20, 30])\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "dfcf7d59",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1 -2 -3]\n",
      "[0 1 2]\n",
      "[11 22 33]\n",
      "[10 40 90]\n",
      "[10. 10. 10.]\n",
      "[0 1 1]\n",
      "[1 0 1]\n",
      "[   10   400 27000]\n"
     ]
    }
   ],
   "source": [
    "print(-a)\n",
    "print(a - 1)\n",
    "print(a + b)\n",
    "print(a * b) # elementwise\n",
    "print(b / a)\n",
    "print(a // 2) # floor division\n",
    "print(a % 2) # mod\n",
    "print(b ** a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "47ec98bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 6]\n",
      "[1 2 6]\n"
     ]
    }
   ],
   "source": [
    "print(np.add.accumulate(a))\n",
    "print(np.multiply.accumulate(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "43625fe5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "+\n",
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]\n",
      " [0. 0. 0.]]\n",
      "=\n",
      "[[1. 2. 3.]\n",
      " [1. 2. 3.]\n",
      " [1. 2. 3.]]\n"
     ]
    }
   ],
   "source": [
    "# NumPy allows you to work with arrays of different dimensions, as if stretching a smaller array to a larger one. \n",
    "# It's called broadcasting.\n",
    "b = np.zeros((3,3))\n",
    "\n",
    "print(a)\n",
    "print('+')\n",
    "print(b)\n",
    "print('=')\n",
    "print(a+b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "fd50fb64",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1,   2,   3,   4,   5,   6,   7,   8,   9,  10],\n",
       "       [  2,   4,   6,   8,  10,  12,  14,  16,  18,  20],\n",
       "       [  3,   6,   9,  12,  15,  18,  21,  24,  27,  30],\n",
       "       [  4,   8,  12,  16,  20,  24,  28,  32,  36,  40],\n",
       "       [  5,  10,  15,  20,  25,  30,  35,  40,  45,  50],\n",
       "       [  6,  12,  18,  24,  30,  36,  42,  48,  54,  60],\n",
       "       [  7,  14,  21,  28,  35,  42,  49,  56,  63,  70],\n",
       "       [  8,  16,  24,  32,  40,  48,  56,  64,  72,  80],\n",
       "       [  9,  18,  27,  36,  45,  54,  63,  72,  81,  90],\n",
       "       [ 10,  20,  30,  40,  50,  60,  70,  80,  90, 100]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(1, 11)\n",
    "np.multiply.outer(a, a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "075c3e15",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.71828183e+00 7.38905610e+00 2.00855369e+01 5.45981500e+01\n",
      " 1.48413159e+02 4.03428793e+02 1.09663316e+03 2.98095799e+03\n",
      " 8.10308393e+03 2.20264658e+04]\n",
      "[0.         0.69314718 1.09861229 1.38629436 1.60943791 1.79175947\n",
      " 1.94591015 2.07944154 2.19722458 2.30258509]\n",
      "[0.         1.         1.5849625  2.         2.32192809 2.5849625\n",
      " 2.80735492 3.         3.169925   3.32192809]\n"
     ]
    }
   ],
   "source": [
    "print(np.exp(a)) # e^a\n",
    "print(np.log(a)) # ln(a)\n",
    "print(np.log2(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "f83a3f18",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([-1, -2, -3])\n",
    "np.abs(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "331cdaac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 2]\n",
      " [2 2]\n",
      " [2 2]]\n",
      "[[2 2 2]\n",
      " [2 2 2]]\n"
     ]
    }
   ],
   "source": [
    "a = np.full((3,2), 2)\n",
    "print(a)\n",
    "b = np.full((2,3), 2)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "308dcb1d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[8, 8, 8],\n",
       "       [8, 8, 8],\n",
       "       [8, 8, 8]])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.matmul(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "d1ce5835",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1 -7  7 -8  7]\n",
      " [-6  4  4  6  2]\n",
      " [-6 -1  1  7 -2]\n",
      " [ 0  8 -7 -4  7]\n",
      " [-2  6  8 -4 -2]]\n"
     ]
    }
   ],
   "source": [
    "a = np.random.randint(-9, 10, (5, 5))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "7c80e490",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.6569866 , -0.2794155 , -0.90929743,  0.7568025 , -0.84147098],\n",
       "       [ 0.90929743, -0.6569866 , -0.6569866 ,  0.7568025 ,  0.2794155 ],\n",
       "       [ 0.6569866 , -0.41211849,  0.90929743, -0.98935825,  0.7568025 ],\n",
       "       [ 0.90929743,  0.6569866 , -0.7568025 ,  0.6569866 , -0.14112001],\n",
       "       [ 0.95892427, -0.84147098,  0.90929743, -0.95892427, -0.7568025 ]])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sin(a) # trigonometry\n",
    "# there are also inverse and hyperbolic trigonometric functions, see documentation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2e376c0",
   "metadata": {},
   "source": [
    "# Boolean arrays, masking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "bee264dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ True False  True False  True]\n",
      " [False  True  True  True  True]\n",
      " [False False  True  True False]\n",
      " [ True  True False False  True]\n",
      " [False  True  True False False]]\n"
     ]
    }
   ],
   "source": [
    "# comparison operators: >, >=, <, <=, !=, ==\n",
    "print(a >= 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "0e3c2094",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 7 7 4 4 6 2 1 7 0 8 7 6 8]\n"
     ]
    }
   ],
   "source": [
    "# boolean masking\n",
    "print(a[a >= 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "e4fa43bf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True,  True,  True,  True],\n",
       "       [ True,  True,  True,  True,  True],\n",
       "       [ True,  True,  True,  True,  True],\n",
       "       [ True,  True,  True,  True,  True],\n",
       "       [ True,  True,  True,  True,  True]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# elementwise comparison\n",
    "a == a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "1a22f93b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(np.any(a > 1)) # there are the elements > 1, at least one\n",
    "print(np.all(a > 1)) # not all the elements > 1\n",
    "\n",
    "# you can specify axis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "29969f6f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False  True  True  True  True]\n",
      " [ True False False  True False]\n",
      " [ True  True False  True  True]\n",
      " [ True  True  True  True  True]\n",
      " [ True  True  True  True  True]]\n"
     ]
    }
   ],
   "source": [
    "# you can use operators such &, |, ~\n",
    "b = ~((a > 0) & (a < 5))\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "207a633a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "print(np.sum(b))\n",
    "print(np.sum(~b))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad7587cd",
   "metadata": {},
   "source": [
    "# Aggregations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "d7d7adac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-80  24 -86  99 -32]\n",
      " [-23  34  82  97  38]\n",
      " [  2 -59 -38  76 -49]\n",
      " [ 95  38  15 -31   7]\n",
      " [-54 -33 -58  92 -78]]\n"
     ]
    }
   ],
   "source": [
    "a = np.random.randint(-99, 100, (5, 5))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "5bea47e2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max: 99\n",
      "Min: -86\n"
     ]
    }
   ],
   "source": [
    "print('Max:', np.max(a))\n",
    "print('Min:', np.min(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "403c2fd3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "99"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "addace01",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-80 -59 -86 -31 -78]\n",
      "[-86 -23 -59 -31 -78]\n"
     ]
    }
   ],
   "source": [
    "print(a.min(axis=0)) # the min within each column\n",
    "print(a.min(axis=1)) # the min within each row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "74338217",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.12\n",
      "3637.7056\n",
      "60.31339486382772\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "print(np.mean(a))\n",
    "print(np.var(a)) # variance\n",
    "print(np.std(a)) # standard deviation\n",
    "print(np.median(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "d9876170",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25th percentile: -49.0\n",
      "75th percentile: 38.0\n"
     ]
    }
   ],
   "source": [
    "# computing quantiles\n",
    "print(\"25th percentile:\", np.percentile(a, 25))\n",
    "print(\"75th percentile:\", np.percentile(a, 75))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12dd4481",
   "metadata": {},
   "source": [
    "# Sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "4a16be1f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([5, 2, 1, 4, 3])\n",
    "np.sort(a)\n",
    "# returns a copy of the array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "9a03933e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 2 1 4 3]\n",
      "[1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "a.sort()\n",
    "print(a)\n",
    "# returns the changed array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "2cbccc5f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 1, 4, 3, 0])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# return indexes\n",
    "a = np.array([5, 2, 1, 4, 3])\n",
    "np.argsort(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "bb844089",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5 2 8]\n",
      " [3 5 1]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[3, 2, 1],\n",
       "       [5, 5, 8]])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# sort by axis\n",
    "a = np.array([[5, 2, 8], [3, 5, 1]])\n",
    "print(a)\n",
    "np.sort(a, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "48fff104",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 5, 8],\n",
       "       [1, 3, 5]])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sort(a, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed8ba583",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}