tools/numpy.ipynb

{
 "metadata": {
  "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
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python_defaultSpec_1596205076603",
   "display_name": "Python 3.8.3 64-bit"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy\n",
    "\n",
    "The note covers the following topics:\n",
    "\n",
    "* array initialization\n",
    "* array attributes\n",
    "* array indexing (single element)\n",
    "* array slicing (subarray)\n",
    "* reshape\n",
    "* computations on numpy array \n",
    "* aggregation\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "vscode": {}
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inintialize array\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])"
     },
     "metadata": {},
     "execution_count": 1
    }
   ],
   "source": [
    "import numpy as np \n",
    "# create len=10 with 0\n",
    "np.zeros(10, dtype=int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([[1., 1., 1., 1., 1.],\n       [1., 1., 1., 1., 1.],\n       [1., 1., 1., 1., 1.]])"
     },
     "metadata": {},
     "execution_count": 2
    }
   ],
   "source": [
    "# creat 3x5 with ones\n",
    "np.ones((3,5), dtype=float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([[3.14, 3.14, 3.14, 3.14, 3.14],\n       [3.14, 3.14, 3.14, 3.14, 3.14],\n       [3.14, 3.14, 3.14, 3.14, 3.14]])"
     },
     "metadata": {},
     "execution_count": 3
    }
   ],
   "source": [
    "# create 3x5 array with 3.14\n",
    "np.full((3,5), 3.14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])"
     },
     "metadata": {},
     "execution_count": 4
    }
   ],
   "source": [
    "# create array filled with linear sequence, start 0, ending at 20, stepping at 2\n",
    "np.arange(0, 20, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([[0.3262544 , 0.72300932, 0.87796151],\n       [0.11140263, 0.49350754, 0.84713479],\n       [0.51267361, 0.4849454 , 0.18375199]])"
     },
     "metadata": {},
     "execution_count": 6
    }
   ],
   "source": [
    "# create an array 3x3 uniformally distributed between 0 and 1\n",
    "np.random.random((3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "vscode": {}
   },
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([[ 0.36494555,  0.75787044, -1.27597714],\n       [ 0.7758699 ,  2.25461967, -0.12817804],\n       [ 0.51040171, -0.16924491, -0.60142025]])"
     },
     "metadata": {},
     "execution_count": 3
    }
   ],
   "source": [
    "# create an array 3x3 normal distributed with mean 0, std dev 1\n",
    "np.random.normal(0, 1, (3,3))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "vscode": {
     "end_execution_time": "2020-07-31T14:03:14.327Z",
     "start_execution_time": "2020-07-31T14:03:14.319Z"
    }
   },
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([[3, 7, 0],\n       [0, 2, 8],\n       [5, 5, 1]])"
     },
     "metadata": {},
     "execution_count": 4
    }
   ],
   "source": [
    "#create 3x3 array of random integers in [0, 10]\n",
    "np.random.randint(0, 10, (3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "vscode": {
     "end_execution_time": "2020-07-31T14:04:07.548Z",
     "start_execution_time": "2020-07-31T14:04:07.538Z"
    }
   },
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([[1., 0., 0.],\n       [0., 1., 0.],\n       [0., 0., 1.]])"
     },
     "metadata": {},
     "execution_count": 6
    }
   ],
   "source": [
    "# create 3x3 identity \n",
    "\n",
    "np.eye(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "vscode": {
     "end_execution_time": "2020-07-31T14:05:21.604Z",
     "start_execution_time": "2020-07-31T14:05:21.590Z"
    }
   },
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([1., 1., 1.])"
     },
     "metadata": {},
     "execution_count": 8
    }
   ],
   "source": [
    "# create uninitialized array, 3 integers\n",
    "np.empty(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array attributes\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "vscode": {}
   },
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "x1 = np.random.randint(10, size=6)         # 1-d \n",
    "x2 = np.random.randint(10, size=(3,4))     # 2-d\n",
    "x3 = np.random.randint(10, size=(3,4,5))   # 3-d\n",
    "x4 = np.random.randint(10, size=(3,4,5,6)) # 4-d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "vscode": {
     "end_execution_time": "2020-07-31T14:16:55.521Z",
     "start_execution_time": "2020-07-31T14:16:55.513Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "x3 ndim = 3\nx3 shape = (3, 4, 5)\nx3 size = 60\nx3 dtype = int64\n"
    }
   ],
   "source": [
    "print(f\"x3 ndim = {x3.ndim}\")\n",
    "print(f\"x3 shape = {x3.shape}\")\n",
    "print(f\"x3 size = {x3.size}\")\n",
    "print(f\"x3 dtype = {x3.dtype}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "x1 = np.random.randint(10, size=6)         # 1-d \n",
    "x2 = np.random.randint(10, size=(3,4))     # 2-d\n",
    "x3 = np.random.randint(10, size=(3,4,5))   # 3-d\n",
    "x4 = np.random.randint(10, size=(3,4,5,6)) # 4-d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "[7 5 1 3 8 4]\n4\n8\n"
    }
   ],
   "source": [
    "print(x1)\n",
    "\n",
    "# using negative index to access the last element\n",
    "print(x1[-1])\n",
    "print(x1[-2])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "[[6 7 8 3]\n [8 7 2 4]\n [3 0 9 8]]\n6\n"
    }
   ],
   "source": [
    "# 2-d example\n",
    "# use [i,j] as index\n",
    "print(x2)\n",
    "print(x2[0,0]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array Slicing\n",
    "\n",
    "The most important property of np sub-array is: it is a **view**, not a copy. Therefore, if you assign the subarray to a variable, and modify it. The change **will be** reflected in the original numpy array.\n",
    "\n",
    "If you do want to make a copy, you need to do something like the following:\n",
    "\n",
    "```\n",
    "x2_sub_copy = x2[:2, :2].copy()\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np \n",
    "x1 = np.random.randint(10, size=10)        # 1-d \n",
    "x2 = np.random.randint(10, size=(3,4))     # 2-d\n",
    "x3 = np.random.randint(10, size=(3,4,5))   # 3-d\n",
    "x4 = np.random.randint(10, size=(3,4,5,6)) # 4-d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1-d array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "[6 9 9 7 2 4 7 1 5 3]\nfirst 3 elements: [6 9 9]\nele after index 2: [9 7 2 4 7 1 5 3]\nmiddle 2 elements: [9 7]\nevery other element: [6 9 2 7 5]\nevery other element, starting from index 1: [9 7 4 1 3]\n"
    }
   ],
   "source": [
    "\n",
    "print(x1)\n",
    "print(f\"first 3 elements: {x1[:3]}\")\n",
    "print(f\"ele after index 2: {x1[2:]}\")\n",
    "print(f\"middle 2 elements: {x1[2:4]}\")\n",
    "print(f\"every other element: {x1[::2]}\")\n",
    "print(f\"every other element, starting from index 1: {x1[1::2]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2-d or more\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([[3, 0, 8, 8],\n       [1, 4, 0, 3],\n       [4, 2, 5, 7]])"
     },
     "metadata": {},
     "execution_count": 28
    }
   ],
   "source": [
    "\n",
    "x2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "two rows, three cols =\n[[3 0 8]\n [1 4 0]]\n"
    }
   ],
   "source": [
    "print(f\"first two rows, first three cols =\\n{x2[:2, :3]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "all rows, every other cols=\n[[3 8]\n [1 0]\n [4 5]]\n"
    }
   ],
   "source": [
    "print(f\"all rows, every other cols=\\n{x2[:, ::2]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "first row - \n[3 0 8 8]\n"
    }
   ],
   "source": [
    "print(f\"first row = \\n{x2[0,:]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reshape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "array([[1, 2, 3],\n       [4, 5, 6],\n       [7, 8, 9]])"
     },
     "metadata": {},
     "execution_count": 33
    }
   ],
   "source": [
    "# put the number 1 to 9 to 3x3 array\n",
    "grid = np.arange(1,10).reshape((3,3))\n",
    "grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "ndim = 1, shape = (3,)\n"
    }
   ],
   "source": [
    "# this is 1-d array\n",
    "x=np.array([1,2,3])\n",
    "print(f\"ndim = {x.ndim}, shape = {x.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "ndim = 2, shape = (1, 3)\n"
    }
   ],
   "source": [
    "# reshape to 2-d array, row vector\n",
    "y = x.reshape((1,3))\n",
    "print(f\"ndim = {y.ndim}, shape = {y.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "ndim = 2, shape = (3, 1)\n"
    }
   ],
   "source": [
    "# reshape it to column vector\n",
    "y = x.reshape((3,1))\n",
    "print(f\"ndim = {y.ndim}, shape = {y.shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### using newaxis\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "ndim = 2, shape = (1, 3)\n"
    }
   ],
   "source": [
    "# using newaxis\n",
    "y = x[np.newaxis, :]\n",
    "print(f\"ndim = {y.ndim}, shape = {y.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "ndim = 2, shape = (3, 1)\n"
    }
   ],
   "source": [
    "# using newaxis\n",
    "y = x[:, np.newaxis]\n",
    "print(f\"ndim = {y.ndim}, shape = {y.shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computation on array\n",
    "\n",
    "numpy provides many *vectorized operation* on its array, which is very efficient. It is implemented as *ufuncs*.\n",
    "\n",
    "### Arithematics, trignometric, exponents, logarithm\n",
    "\n",
    "A list of common operations \n",
    "```\n",
    " np.add, np.subtract, np.negative, np.multiply\n",
    " np.divide, np.floor_divide, np.power, np.mod\n",
    " np.abs, np.sin, np.cos, np.tan \n",
    " np.log, np.log2, np.log10\n",
    " np.exp(x)      # e^x\n",
    " np.exp2(x)     # 2^x\n",
    " np.power(3,x)  # 3^x\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Specifying output\n",
    "\n",
    "On large calculation, specifying output can be more efficient\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "[ 0. 10. 20. 30. 40.]\n"
    }
   ],
   "source": [
    "x = np.arange(5)\n",
    "y = np.empty(5)\n",
    "np.multiply(x, 10, out=y)\n",
    "print(y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aggregation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ]
}