numpy/basic_operations.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.7.7-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.7.7 64-bit",
   "metadata": {
    "interpreter": {
     "hash": "1005f71a2f2c9f7da6acb75e9bc0247674183f6cab85bd2a339bd069fc0cd207"
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# Numpy Basic Operations"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "source": [
    "## Sort"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(5)\n",
    "a = np.sort(a)  # not an in-place sorting\n",
    "# [0, 1, 2, 3, 4]\n",
    "\n",
    "a[::-1].sort()  # perform in-place sorting\n",
    "# [4, 3, 2, 1, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[[0, 7, 6, 4],\n",
       "        [4, 8, 0, 6],\n",
       "        [2, 0, 5, 9]],\n",
       "\n",
       "       [[7, 7, 7, 7],\n",
       "        [5, 1, 8, 4],\n",
       "        [5, 3, 1, 9]]], dtype=int64)"
      ]
     },
     "metadata": {},
     "execution_count": 38
    }
   ],
   "source": [
    "a = np.random.default_rng(42).integers(0, 10, (2,3,4))\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[[0, 4, 6, 7],\n",
       "        [0, 4, 6, 8],\n",
       "        [0, 2, 5, 9]],\n",
       "\n",
       "       [[7, 7, 7, 7],\n",
       "        [1, 4, 5, 8],\n",
       "        [1, 3, 5, 9]]], dtype=int64)"
      ]
     },
     "metadata": {},
     "execution_count": 40
    }
   ],
   "source": [
    "np.sort(a, axis=-1)  # default: sort on last (axis=2 in this case) dimension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[[0, 0, 0, 4],\n",
       "        [2, 7, 5, 6],\n",
       "        [4, 8, 6, 9]],\n",
       "\n",
       "       [[5, 1, 1, 4],\n",
       "        [5, 3, 7, 7],\n",
       "        [7, 7, 8, 9]]], dtype=int64)"
      ]
     },
     "metadata": {},
     "execution_count": 45
    }
   ],
   "source": [
    "np.sort(a, axis=1)  # sort on the second demension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([9, 9, 8, 8, 7, 7, 7, 7, 7, 6, 6, 5, 5, 5, 4, 4, 4, 3, 2, 1, 1, 0,\n",
       "       0, 0], dtype=int64)"
      ]
     },
     "metadata": {},
     "execution_count": 47
    }
   ],
   "source": [
    "np.sort(a, axis=None)[::-1]  # sort on all elements and flatten"
   ]
  },
  {
   "source": [
    "Note: The `axis` uses in `np.sort()` is not as in `max()`, `mean()` and other functions.\n",
    "\n",
    "- `axis=None` will sort the arrays into **flattened** arrays.\n",
    "- `axis=n` will sort the arrays on the `n-th` dimension.\n",
    "    - e.g., `np.sort((3, 3, 1), axis=2)` will sort the elements on the last dimension. "
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## Concatenate"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "(array([[2, 1]]),\n",
       " array([[0, 1],\n",
       "        [2, 3]]))"
      ]
     },
     "metadata": {},
     "execution_count": 9
    }
   ],
   "source": [
    "a = np.array([[2, 1]])\n",
    "b = np.arange(4).reshape(2, 2)\n",
    "a, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[2 1 0 1 2 3]\n[[2 1]\n [0 1]\n [2 3]]\n[[2 0 1]\n [1 2 3]]\n"
     ]
    }
   ],
   "source": [
    "print(  np.concatenate((a, b), axis=None)  )\n",
    "print(  np.concatenate((a, b), axis=0)     )  # default axis\n",
    "print(  np.concatenate((a.T, b), axis=1)   )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[[[0]\n  [1]\n  [2]]\n\n [[3]\n  [4]\n  [5]]\n\n [[6]\n  [7]\n  [8]]]\n[[[ 0  1]\n  [ 2  3]\n  [ 4  5]]\n\n [[ 6  7]\n  [ 8  9]\n  [10 11]]\n\n [[12 13]\n  [14 15]\n  [16 17]]]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(9).reshape(3, 3, 1)\n",
    "b = np.arange(18).reshape(3, 3, 2)\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14\n 15 16 17]\n[[[ 0  0  1]\n  [ 1  2  3]\n  [ 2  4  5]]\n\n [[ 3  6  7]\n  [ 4  8  9]\n  [ 5 10 11]]\n\n [[ 6 12 13]\n  [ 7 14 15]\n  [ 8 16 17]]]\n"
     ]
    }
   ],
   "source": [
    "print(  np.concatenate((a, b), axis=None)  )\n",
    "print(  np.concatenate((a, b), axis=2)     )"
   ]
  },
  {
   "source": [
    "Note: The `axis` uses in `np.concatenate()` is not as in `max()`, `mean()` and other functions.\n",
    "\n",
    "- `axis=None` will merge the arrays into **flattened** arrays.\n",
    "- `axis=n` will merge the arrays on the `n-th` dimension.\n",
    "    - e.g., `np.concatenate((3, 3, 1), (3, 3, 2), axis=2) = (3, 3, 3)`"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## Artithemetics\n",
    "\n",
    "Arithmetic operators on arrays apply elementwise."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a =    [0 1 2 3 4]\nb =    [1 1 1 1 1]\na+b  = [1 2 3 4 5]\na-b  = [-1  0  1  2  3]\na^2  = [ 0  1  4  9 16]\na*10 = [ 0 10 20 30 40]\na>2  = [False False False  True  True]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(5)\n",
    "b = np.ones(5, dtype=int)\n",
    "\n",
    "print(f\"a =    {a}\", f\"b =    {b}\", sep=\"\\n\")\n",
    "print(f\"a+b  = {a+b}\")\n",
    "print(f\"a-b  = {a-b}\")\n",
    "print(f\"a^2  = {a**2}\")\n",
    "print(f\"a*10 = {a*10}\")\n",
    "print(f\"a>2  = {a>2}\")"
   ]
  },
  {
   "source": [
    "## Product\n",
    "\n",
    "Unlike in many matrix languages, product operator `*` operates elementwise in numpy, the **dot product** or **matrix product** can be performed by the `@` operator or `dot()` method."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a =   [0 1 2 3 4]\nb =   [1 1 1 1 1]\na*b = [0 1 2 3 4]\na@b = 10\na.dot(b) = 10\n"
     ]
    }
   ],
   "source": [
    "print(f\"a =   {a}\", f\"b =   {b}\", sep=\"\\n\")\n",
    "print(f\"a*b = {a*b}\")\n",
    "print(f\"a@b = {a@b}\")\n",
    "print(f\"a.dot(b) = {a.dot(b)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "c:\n[[1 2]\n [3 4]]\nd:\n[[1 7]\n [6 4]]\n\nc*d=\n[[ 1 14]\n [18 16]]\n\nc@d=\n[[13 15]\n [27 37]]\n"
     ]
    }
   ],
   "source": [
    "c = np.array([[1, 2], [3, 4]])\n",
    "d = np.random.default_rng(42).integers(1, 10, (2, 2))\n",
    "\n",
    "print(\"c:\", c, \"d:\", d, sep=\"\\n\")\n",
    "print()\n",
    "print(f\"c*d=\\n{c*d}\")\n",
    "print()\n",
    "print(f\"c@d=\\n{c@d}\")"
   ]
  },
  {
   "source": [
    "## Upcasting\n",
    "\n",
    "**Upcasting** will automatically convert the different types to the precise one."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[1 1 1]\n[0.         1.57079633 3.14159265]\n[1.         2.57079633 4.14159265]\n"
     ]
    }
   ],
   "source": [
    "e = np.ones(3, dtype=np.int32)\n",
    "f = np.linspace(0, np.pi, 3)\n",
    "\n",
    "print(e)\n",
    "print(f)\n",
    "print(e+f)"
   ]
  },
  {
   "source": [
    "## Functions\n",
    "\n",
    "By specifying the axis parameter you can apply an operation along the specified axis of an array:\n",
    "\n",
    "- **None**: all elemnts in the array or matrix\n",
    "- **0**: each columns\n",
    "- **1**: each rows"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[[0.77395605 0.43887844 0.85859792 0.69736803]\n [0.09417735 0.97562235 0.7611397  0.78606431]]\n\nm.sum():  5.385804144070475\nm.sum(axis=0):  [0.8681334  1.41450079 1.61973762 1.48343233]\nm.sum(axis=1):  [2.76880044 2.61700371]\n\nm.min() 0.09417734788764953\nm.min(axis=0) [0.09417735 0.43887844 0.7611397  0.69736803]\nm.min(axis=1) [0.43887844 0.09417735]\n\nm.max() 0.9756223516367559\nm.max(axis=0) [0.77395605 0.97562235 0.85859792 0.78606431]\nm.max(axis=1) [0.85859792 0.97562235]\n"
     ]
    }
   ],
   "source": [
    "m = np.random.default_rng(42).random((2, 4))\n",
    "print(m)\n",
    "print()\n",
    "print(\"m.sum(): \", m.sum())\n",
    "print(\"m.sum(axis=0): \", m.sum(axis=0))\n",
    "print(\"m.sum(axis=1): \", m.sum(axis=1))\n",
    "print()\n",
    "print(\"m.min()\", m.min())\n",
    "print(\"m.min(axis=0)\", m.min(axis=0))\n",
    "print(\"m.min(axis=1)\", m.min(axis=1))\n",
    "print()\n",
    "print(\"m.max()\", m.max())\n",
    "print(\"m.max(axis=0)\", m.max(axis=0))\n",
    "print(\"m.max(axis=1)\", m.max(axis=1))"
   ]
  },
  {
   "source": [
    "### Universal Functions\n",
    "\n",
    "NumPy provides familiar mathematical functions such as **sin**, **cos**, and **exp** (These are called **universal functions**). They all operate elementwise on an array.\n",
    "\n",
    "> exp, sqrt, all, any, apply_along_axis, argmax, argmin, argsort, average, bincount, ceil, clip, conj, corrcoef, cov, cross, cumprod, cumsum, diff, dot, floor, inner, invert, lexsort, max, maximum, mean, median, min, minimum, nonzero, outer, prod, re, round, sort, std, sum, trace, transpose, var, vdot, vectorize, where"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "A = [0 1 2 3]\nnp.sqrt(A) = [0.         1.         1.41421356 1.73205081]\nnp.exp(A) = [ 1.          2.71828183  7.3890561  20.08553692]\nnp.mean(A) = 1.5\nnp.median(A) = 1.5\nnp.all(A) = False\nnp.any(A) = True\n"
     ]
    }
   ],
   "source": [
    "A = np.arange(4)\n",
    "print(f\"A = {A}\")\n",
    "print(f\"np.sqrt(A) = {np.sqrt(A)}\")\n",
    "print(f\"np.exp(A) = {np.exp(A)}\")\n",
    "print(f\"np.mean(A) = {np.mean(A)}\")\n",
    "print(f\"np.median(A) = {np.median(A)}\")\n",
    "print(f\"np.all(A) = {np.all(A)}\")\n",
    "print(f\"np.any(A) = {np.any(A)}\")"
   ]
  },
  {
   "source": [
    "# Reference\n",
    "\n",
    "- https://numpy.org/doc/stable/user/quickstart.html#basic-operations\n",
    "- https://numpy.org/doc/stable/user/absolute_beginners.html#adding-removing-and-sorting-elements\n",
    "- https://numpy.org/doc/stable/user/absolute_beginners.html#basic-array-operations\n",
    "- https://numpy.org/doc/stable/user/absolute_beginners.html#more-useful-array-operations"
   ],
   "cell_type": "markdown",
   "metadata": {}
  }
 ]
}