{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": [
     "remove_cell"
    ]
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Array Conditional Statements and `numpy.where()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparison and Bitwise Operations on Arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can apply comparison operators to arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True, False,  True,  True, False])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1 = np.array([1,  2, 3, 4, 5])\n",
    "\n",
    "a2 = np.array([2, 1, 5, 6, 4])\n",
    "\n",
    "a1 < a2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see this gives us an array of booleans, each element representing the outcome of comparing the corresponding element of `a1` to `a2`. \n",
    "\n",
    "What if we wanted to combine the boolean arrays with a logical operator? For example, if we want an array of booleans for the condition `a1` is less-than `a2` and greater than `2`. Unfortunately the boolean comparison operators we used in [**Standard Library/If Statements/Comparison Operators**](../../standard-library/if-statements/comparison-operators) won't work. For example using `and`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-53-74cb81b02f02>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma1\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0ma2\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0ma1\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()"
     ]
    }
   ],
   "source": [
    "a1 < a2 and a1 > 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to combine boolean arrays (without a loop) we need to use **bitwise** operators."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bitwise operators treat numbers as a string of bits and act on them bit by bit. In the case of a boolean array, the operator acts on it element by element. The bitwise operators we are interested are:\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <th>Operator</th>\n",
    "        <th>Name</th>\n",
    "        <th>Analogous boolean operator</th>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td><code>&</code></td>\n",
    "        <td>Bitwise and</td>\n",
    "        <td><code>and</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td><code>|</code></td>\n",
    "        <td>Bitwise or</td>\n",
    "        <td><code>or</code></td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td><code>~</code></td>\n",
    "        <td>Bitwise complement</td>\n",
    "        <td><code>not</code></td>\n",
    "    </tr>\n",
    "</table>\n",
    "\n",
    "(See <https://wiki.python.org/moin/BitwiseOperators> for a more comprehensive list and explanation of bitwise operations.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Returning to our original example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False,  True,  True, False])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(a1 < a2) & (a1 > 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the comparisons must be grouped in brackets for this to work:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "tags": [
     "raises-exception"
    ]
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-56-c3606bc24b97>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma1\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0ma2\u001b[0m \u001b[0;34m&\u001b[0m \u001b[0ma1\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()"
     ]
    }
   ],
   "source": [
    "a1 < a2 & a1 > 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"worked-example\">\n",
    "    <h5 class=\"worked-example-title\"><b>Worked Example</b> - Random Points in a Region</h5>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use `np.where()` to check which points in an array lie inside or outside of region.\n",
    "\n",
    "First let's generate an array of 50 random points in 2D space:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "points = np.random.random((2, 50))\n",
    "\n",
    "plt.plot(points[0, :], points[1, :], 'ro')\n",
    "\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that axis 0 of `points` is used to represent the x and y values, and axis 1 represents points. i.e. for the points $(x_0, y_0), (x_1, y_1), \\dots, (x_{49}, y_{49})$, `points` is:\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td>x0</td>\n",
    "        <td>x1</td>\n",
    "        <td>x2</td>\n",
    "        <td>x3</td>\n",
    "        <td>x4</td>\n",
    "        <td>...</td>\n",
    "        <td>x48</td>\n",
    "        <td>x49</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>y0</td>\n",
    "        <td>y1</td>\n",
    "        <td>y2</td>\n",
    "        <td>y3</td>\n",
    "        <td>y4</td>\n",
    "        <td>...</td>\n",
    "        <td>y48</td>\n",
    "        <td>y49</td>\n",
    "    </tr>\n",
    "</table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's plot the points which lie to the left of 0.5 as blue and the others as red:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'y')"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "is_left = points[0, :] < 0.5 #True where left of 0.5\n",
    "\n",
    "plt.plot(points[0, is_left], points[1, is_left], 'bo')\n",
    "plt.plot(points[0, ~ (is_left)], points[1, ~ is_left], 'ro')\n",
    "\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that, in the example above, we have used an array of booleans to **slice the elements of the array which are true**. We have also use the **bitwise compliment** to get the complement of our comparison result, there is no need to recalculate it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, lets plot the points right of 0.5 and above 0.5 (the top left square) as red and the rest as blue (remember the **bitwise and**):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'y')"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#True if in top left square\n",
    "is_top_left = (points[0, :] > 0.5) & (points[1, :] > 0.5)\n",
    "\n",
    "plt.plot(points[0, is_top_left], points[1, is_top_left], 'ro')\n",
    "plt.plot(points[0, ~ (is_top_left)], points[1, ~ is_top_left], 'bo')\n",
    "\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `numpy.where()`\n",
    "\n",
    "[Documentation](https://docs.scipy.org/doc/numpy/reference/generated/numpy.where.html)\n",
    "\n",
    "```python\n",
    "numpy.where(condition[,x, y])\n",
    "```\n",
    "\n",
    "Returns elements chosen from `x` or `y` depending on the condition. If no `x` or `y` arguments are provided it returns and array of indices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arr1: [10 11 12 13 14 15 16 17 18 19]\n",
      "Indices where arr1 is greater than 15: (array([6, 7, 8, 9]),)\n",
      "The sub-array of arr1 that is greater than 15: [16 17 18 19]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(10, 20)\n",
    "\n",
    "arr_where = np.where(arr > 15) \n",
    "\n",
    "print('arr1:', arr)\n",
    "print('Indices where arr1 is greater than 15:', arr_where)\n",
    "print('The sub-array of arr1 that is greater than 15:', arr[arr_where])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If both `x` and `y` is specified, the elements of the returned array come from `x` if `condition` is true, or from `y` if `condition` is false."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: [1. 2. 3. 4. 5.]\n",
      "y: [-1. -2. -3. -4. -5.]\n",
      "Condition: [True, False, True, True, False]\n",
      "x where True, y where False: [ 1. -2.  3.  4. -5.]\n"
     ]
    }
   ],
   "source": [
    "x = np.linspace(1, 5, 5)\n",
    "#y = np.linspace(-5, -1, 5)\n",
    "y = -x\n",
    "\n",
    "condition = [True, False, True, True, False] \n",
    "\n",
    "print('x:', x)\n",
    "print('y:', y)\n",
    "print('Condition:', condition)\n",
    "print('x where True, y where False:', np.where(condition, x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"worked-example\">\n",
    "    <h5 class=\"worked-example-title\"><b>Worked Example</b> - Piecewise Defined Functions</h5>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One use for `np.where()` is to define a piecewise defined function that works on arrays.\n",
    "\n",
    "As a first example, let's use `np.where()` to plot the absolute value function (you should really use `np.abs()` for this):\n",
    "\n",
    "$$\n",
    "y =\n",
    "\\begin{cases}\n",
    "-x & \\text{if $x < 0$}\\\\\n",
    "x & \\text{if $x \\geq 0$}\\\\\n",
    "\\end{cases}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(-1, 1)\n",
    "\n",
    "y = np.where(x >= 0, x, -x)\n",
    "\n",
    "plt.plot(x, y)\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that, in the plot above, the line does not reach zero, but flattens out to a value above it. This is because the array `x` does not contain the value 0, but values around it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, consider the piecewise function:\n",
    "\n",
    "$$\n",
    "f(x) =\n",
    "\\begin{cases}\n",
    "-(x + 1)^2 + 1 & \\text{if $x < -1$}\\\\\n",
    "- x & \\text{if $-1 \\leq x \\geq 1$}\\\\\n",
    "(x - 1)^3 - 1 & \\text{if $x > 1$}\n",
    "\\end{cases}\n",
    "$$\n",
    "\n",
    "where there are three regions. To handle this we can use 2 `np.where()` calls:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(-3, 3)\n",
    "\n",
    "#Left condition\n",
    "y = np.where(x < -1, -(x+1)**2 + 1, -x)\n",
    "\n",
    "#Right condition\n",
    "y = np.where(x > 1, (x - 1)**3 - 1, y)\n",
    "\n",
    "plt.plot(x, y)\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "</div>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.3 64-bit ('base': conda)",
   "language": "python",
   "name": "python37364bitbaseconda97808f46a65a4f1e9dfdbcff18a07fbf"
  },
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}