week02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## CS102 - Further Computing\n",
    "\n",
    "Mark Howard<br>\n",
    "School of Mathematical & Statistical Sciences<br>\n",
    "NUI Galway<br>\n",
    "mark.howard@nuigalway.ie\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### 1. Aspects of Scientific Computing\n",
    "\n",
    "# Week 2: Understanding `python` Data Types\n",
    "Here, we review `python`'s basic data types, and some\n",
    "of their properties."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Dynamic Typing\n",
    "* A statically-typed language like `C` or `Java` requires each \n",
    "  variable to be explicitly declared, together with a type.\n",
    "\n",
    "* In a dynamically-typed language like `python` this kind of\n",
    "  specification is not needed, a variable is implicitly declared\n",
    "  when it is first used."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Dynamic Typing\n",
    "* For example, in `C` one might specify a particular operation as follows:\n",
    "\n",
    "```C\n",
    "/* C code */\n",
    "int result = 0;\n",
    "for (int i = 0; i < 100; i++) {\n",
    "    result += i;\n",
    "}\n",
    "```\n",
    "* In `python` the equivalent operation could be written this way:\n",
    "\n",
    "```python\n",
    "# Python code\n",
    "result = 0\n",
    "for i in range(100):\n",
    "    result += i\n",
    "```\n",
    "* In `C`, the data type of each variable (`int` for integer) is\n",
    "  explicitly declared (and thus known to the compiler).\n",
    "* In `python`, the data type is **dynamically** inferred\n",
    "  (at runtime) from the **value** of the variable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* In `python`, one can write and execute the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "value = 0.0\n",
    "print(value == 0)\n",
    "value = \"0\"\n",
    "print(value == 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* The corresponding `C` code  would fail to compile."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* The standard `python` interpreters (and `ipython` too)\n",
    "are implemented in `C`.\n",
    "* Thus, at runtime, every `python` object is also a `C` object.\n",
    "* However, there is a big difference between a `C` variable\n",
    "  storing a `C` integer as value, and a `python` variable\n",
    "  holding a `python` integer ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* A `C` integer variable is essentially a label for a **slot** in \n",
    "  machine memory whose bytes encode an integer value.\n",
    "* A `python` variable is a **pointer** to a complex structure in \n",
    "  memory, which contains administrative information about a\n",
    "  `python` object (such as its **type**) in addition to the \n",
    "  integer value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* The integer (long) type definition effectively looks like this:\n",
    "\n",
    "```C\n",
    "/* C code */\n",
    "struct _longobject {\n",
    "    long ob_refcnt;\n",
    "    PyTypeObject *ob_type;\n",
    "    size_t ob_size;\n",
    "    long ob_digit[1];\n",
    "};\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A single integer in Python 3 thus actually contains four pieces:\n",
    "\n",
    "* `ob_refcnt`, a **reference** count that helps Python silently handle memory allocation and deallocation\n",
    "* `ob_type`, which encodes the **type** of the object\n",
    "* `ob_size`, which specifies the **size** of the object (i.e., its number of digits)\n",
    "* `ob_digit`, the array of digits representing an actual integer value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "![](images/cint_vs_pyint.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* The function `sys.getsizeof` reveals that in `python`, there is \n",
    "  an administrative overhead of $24$ bytes for each integer, whose\n",
    "  value only requires $4$ bytes (if it is small) ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from sys import getsizeof\n",
    "print(getsizeof(0))\n",
    "print(getsizeof(100))\n",
    "print(getsizeof(2**30-1))\n",
    "print(getsizeof(2**30))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* This memory overhead becomes even more drastic when it comes to \n",
    "  **lists** of integers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lists in `python`\n",
    "* Dynamic typing allows lists in `python` to be heterogeneous."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "L = [True, 2, 3.0, \"4\"]\n",
    "[(x, type(x)) for x in L]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* This flexibility comes at a price: each object in the list\n",
    "  stores their own administrative information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "getsizeof(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "[(x, getsizeof(x)) for x in L]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* If all the objects in a list are of the same type, most of\n",
    "  this information is redundant.\n",
    "* It would be more efficient to store these data in a\n",
    "  fixed-type array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "#The contents plus the list object\n",
    "P = [2, 3, 5, 7, 11, 13, 17, 19]\n",
    "sum(getsizeof(x) for x in P) + getsizeof(P)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## `NumPy` Arrays\n",
    "* The `numpy` package provides efficient storage and\n",
    "  efficient operations on array based data.\n",
    "  \n",
    "  ![](images/cint_vs_pyint.png)\n",
    "\n",
    "* At the implementation level, the `numpy` array essentially contains a single pointer to one contiguous block of data. \n",
    "* The Python list, on the other hand, contains a pointer to a block of pointers, each of which in turn points to a full Python object like the Python integer (above) that we saw earlier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![](images/array_vs_list.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## `NumPy` Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* A `numpy` fixed-type array can be constructed from a `python` list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a = np.array([3,1,4,1,5,9,2,6])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "np.array(range(10))"
   ]
  },
  {
   "attachments": {
    "Screenshot%201-13-22%20at%2016.11.22.png": {
     "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAD/CAIAAADzFgyXAAAgAElEQVR4nO3dd5wV5b0/8O/zzMyp23uFpfcqCAgoYlSMgjXmJt6IITF61ZfReNXcaCw3aqLmlZ8J5iZR440aIxaMBY2IoBQFpCPL0tkC7LJsP33K8/z+eHYPh2LLzbDAft5/8FrmzJl59pzZ5zNPmRkmpSQAAAD4V+PdXQAAAIDTEyIWAADAFYhYAAAAVyBiAQAAXIGIBQAAcAUiFgAAwBWIWAAAAFcgYgEAAFyBiAUAAHAFIhYAAMAViFgAAABXIGIBAABcgYgFAABwBSIWAADAFYhYAAAAVyBiAQAAXIGIBQAAcAUiFgAAwBWIWAAAAFcgYgEAAFyBiAUAAHAFIhYAAMAVencXAOAEkVIyxqSUqQuTS9QPn7cCY+yElhUATgtHVygAcJJLRv5x/3hxNgBw8kArFnqKZCM1kUhEo1HOud/v93q9R7ViLcsKh8NCCJ/P5/f7OecnWyv2uIU5qUoIAArGYqGnUFFqmubjjz8+ZsyYqVOn/va3vyUix3HUS7ZtE9HixYsnT548YsSIH//4x42NjUQkhOjWgh8t2XhlKdRCdEoBnFQQsdBTqHaeaZqLFi2qra3dsmXLO++8Q0RCCPWSitJdu3ZVVVXV19dv3Ljx0KFDdPLlVrI84XC4srKysrJy586dRCSEONmKCtDDoaMYehbGmMfjUZnq9/sppYtV/cA5V41CTdM452p5Mr3UEinlsU1JOnJGVeq/yRWSjm10Jtc5asrVcfclpRRCLF269JJLLiGi7Ozs/fv3c851XU9d+V/6yQHA14aIhR4nmZeO4xx3haPyT8Vt6qsqaI96S2qOHpuplBLAx301ddepgX3smkIIzrmmaZmZmYZhEFF+fr5hGLquU8pkKADodohY6HGOarZ+lfX379+/b98+x3FGjRoVDAYPHDhQV1fnOI6maWVlZaWlpalNT7XZhoaG+vr6WCzGGMvJyenbt69hGCr/bNtuampqaWkJh8NqANgwjPz8/F69eiVnV6kcjcVi1dXVbW1tauPZ2dkVFRU+ny8SiWzevHnNmjWWZRFRR0fHkiVLgsFgWlraqFGjVNc3ghag2yFiAb6Epmlz58599NFHiWjBggU+n+/RRx9dtGiRevXss8++/fbbZ86cqWmaSsdwOPzaa6+9/PLL7733nlqnvLz8xhtvnD17dnFxsWVZCxYseOqppzZu3Hjw4MHkXkaNGnXNNdfMmTMnNzdXhfe2bdueeeaZF154Qc26IqLi4uLbbrvtrrvu2rRp0+TJk5PvbWhouPDCC4moT58+VVVVqV3cJ+QTAoDjQ8QCfAkppc/n83q9RPT8888vXry4ublZvaTr+rJly9avX//222+fc845qvX5yCOP/PKXv0zdQl1d3T333GPb9n333dfc3Pzcc88tXLjwqL1s2rRp06ZNhmHcfPPNjLFoNHrnnXcuWLAgdZ36+vq5c+feddddyQHjozZiGIZpmoFAgJCvACcBRCzAl0heTUtEr7zyiqZpU6ZMycvLa2hoWLt2raZp4XD4mWeemTRpktfrXb9+/a9+9StN0xzH6dWr19ixY4UQO3furKqq2rNnjxrWzcjIyM7OHjFihN/vV6G4bt261tZWTdPmzZt38cUXDxgwYN26dWvWrNF1PRgMTp8+nYgikci+ffsCgYCUsri4+Nprr927d++yZcuIKBgMXnDBBY7jDB48OD093bIsNe8JKQvQvRCx0HN99UtckmsGAoGbbrrpnnvuycrKamlpueyyy5YvX84Y++ijj6LRqGEY8+bNY4w5jlNSUvLMM8+cf/75RLRhw4b77ruvf//+jLH09PQrr7xy+vTps2fPTk6b+tOf/nTnnXeGQqEdO3Y0NTX1798/Eolwzh3HCQQCv//974uLi4lo69atmzdvllL27t37L3/5y9atW4cNG0ZEJSUlr7/+utqUEELX9eO2cQHgBEPEQo927OThL74rYXl5+d13352VldXR0ZGTk3PFFVesXLnStu39+/dblhWLxT777DM122jWrFnnn39+OBzWdX3MmDF///vfa2pqpJSGYVx22WVEVFNTs3v37oMHD3LO29raMjIyQqGQ3+9X1xT179/f7/dLKevr66+44opzzjln/Pjxs2bNGjp0qBBCCGGa5o4dO1SpEonE/v37s7OzGWPqXWjCApwMELHQs6SGqJq+m7w2Rv2cvD5HdknNqkAg0NbWlpOTEwgEhBCjR4/2+/2hUEiNwiYSiba2NiLSNK2oqMiyLJ/Pp2mamjbcr18/1cSsqal56qmnVq9evXHjxuSwrmLbttpdr169brnllrvvvtuyrFWrVq1atYpz/r3vfe+OO+4YMWIEEfl8Pp/Pl/xFAoGA1+s99qkGbn+eAPAFELHQg6jUUdePElE4HOacq8tk1Uuc83A4rF5V83KPSim1MNn2NU0zdcuUckmrunw2efNFtVPGWH19/a233vrWW28RUSAQ6N+/P+e8o6OjubnZsqzk7kzTvOmmm/x+/zvvvFNVVbV7924hxHPPPbdjx4633347Nzf3qN9LXeMrhNA0DfkKcJLADRShR0i27XRdr6ioUE3VXbt2bdq0yefzmaaZSCQ8Hk9ra+v777+v1iwqKiopKTnq9hRNTU1paWmapsXjcU3Tli9fHo1GiUjXdXVzpWAwSERCiD179miaJoSwbVvX9UOHDqlR23feeeett94yDGPatGnPP//83Llzn3/++UceeUSNtiavZ/V4PF6v98Ybb3z22WeffPLJe++9V91oYuXKlUuWLDnqt9M0ze/3qx0hXwFOHohY6BGS/cAej0dNvvV4PI2Njbfccssnn3yiHqpTXV3985///KOPPlJXuI4ePTorKysej6dup66u7qGHHqqvr09LS9uyZcv8+fMdx+GcDxkyxOv1BgKBvn37qn0tXLhw/vz5Xq/XMIzVq1fPmTNn3rx5Usq9e/cahmFZVm5u7pVXXjljxowRI0ZUV1cnW8+q4bt9+/annnpq8+bN+fn5M2bM+MUvflFaWmpZlsfj2bZtW/K5BepcoaOjY9u2bV6vt76+Xo0EY64TwMkAHcXQIyRvXsg5P+ecc0aPHr1x40av17tixYo5c+ZMnz5d1/XNmzcvX75c13XHcfr27Ttr1qxjg8pxnLlz5+7YsWP48OEfffRRVVWVysurrroqGAxqmnbppZc+88wzuq6r/F60aJGmacuWLduyZcucOXOIKCcnx7Isr9f7/vvvX3rppRUVFdu2bVu0aFGy81m1mxctWnTnnXeOHj166NChgUCgvb394MGDuq6bpjl8+HD1u5SXlzuOYxhGU1PTzTffPH78eNM0f/3rX6elpaXeiBEAuo0E6AHEkdasWTNlypTP+6Po37//ggULHMdxHCcej0sp77vvPvVSYWFhVlZWck2VYVOmTKmrq1N7icViP/3pT4+72ccee0xKuXHjxiFDhtAx+RcMBr1eb3Fx8apVq4QQTz755LF3QiaimTNnhkIh9QC+SCQybtw4IvJ4POrVoqKipqYm1TvdvR84AEgptQceeOBrRTLAqeioPCstLT377LNLSkra2tpUJqnlI0eOvO666+69995zzz1XvctxHF3XP/roo6VLlxLRgAEDfvWrXwUCgU2bNhFRRkbG7NmzH3nkkb59+0opicgwjMmTJ5eXlx88ePDAgQNqs9OnT/+v//qvq6++2u/3FxYWjhgxorW1ddu2berV0aNH33///dFodPv27Yyx66+/vri4OC8vr6Wl5dChQ8kO5D59+tx66633339/Xl6eWqLr+vjx46urq5NX71x33XUzZ84kItWBjFYsQPfCmA30CDLlMXNEpIKTiCorK2tra5ubm6WUgUBg4MCB6pIYx3HUBON4PO7z+e6///7//u//JqJRo0YtXbrUsqxFixbZtl1SUjJp0qRAIKBGZGXKA++2bdtWWVkZjUaDweDo0aP79u1LXc+mZYwdPHhwzZo1ra2tfr9/4MCBI0eOrKqqWrt2bV5e3uTJk9PT0xljDQ0Nu3btqq2tVTegKCsrmzBhAnU9aUd2zWmqra1duXJlIpHIzs4eN25ccXGxKgwhYgG6GyIWegqZ8iw5KaVKu+N2xqqpuepPwzRNr9ebjNgxY8a8+uqr/fr1S11fRVpy4+oqoNTn31FKZqvuo6P2q1IztajHrpO6L0qZwHXUaqm/5tf9iADgXwvTnaCnSM1XxpiaNqwGNWXKg9OTDzZPjSi1PhGpV4UQlmWpWFWPbqUjZ1Slbjm52dTkU0PCqa86jqNSX13YmrpOatlS74yRXE3NkFIrJBu4SFmAboeIhR4kNWWpK5OSOZR86aheZZWXKsYsy5Jd969IbU3SkTdUSkbycTebzMvUsiXvdJFck7puWHHUdijl8tnkpo67F1c/TAD4UohY6FlS78FER45WHvcl1aa8+OKLQ6FQY2Pj9OnT8/PzWZejNnLcVPuCPX6tNY969Z/eCwCcMBiLBfhcqQ3ZWCyWSCTS09NTW5ZIMgD4AohYgM913E7XY7uFAQCOCxEL8EWOGpellBv9I18B4IvhHsUAn+uoGUaUcqkM7gMMAF8K1QQAAIAr0IoFAABwBSIWAADAFYhYAAAAVyBiAQAAXIGIBQAAcAUiFgAAwBWIWAAAAFcgYgEAAFyBiAUAAHAFIhYAAMAViFgAAABXIGIBAABcgYgFAABwBSIWAADAFYhYAAAAVyBiAQAAXIGIBQAAcAUiFgAAwBWIWAAAAFcgYgEAAFyBiAUAAHAFIhYAAMAViFgAAABXIGIBAABcgYgFAABwBSIWAADAFYhYAAAAVyBiAQAAXIGIBQCAr0pKqf5VkkvguBCxAADwVTHG1L9CCNu2hRBqOYL2uBg+FwAA+IqklIwx9S8RCSEcx9E0jXOeXAhJaMUCAMBXlewcfvHFF3/xi1+0t7cbhsE5N00zdQVQ9O4uABGR6nDo7lIAAMCXSDZVa2trH3roofnz50+dOvWOO+6oqKhIJBK6rnPOqSto0ag9KSKWc+7xeLq7FAAA8FXl5+ebprlp06aqqqr58+dfddVVv/nNbzRNE0IwxhCuykkxFvv+++/feOON3V0KAAD4qjo6Opqbm5P/5ZyXl5ffdtttN9xwg8/nSy7v4Vl7UrRiw+Hw3r17u7sUAADwz9A0zXGcmpqalStXXnTRRYMGDVIzjVWncU92UrRio9FoY2NjDz/ZAQA4+amxWF3Xn3766QcffFCFKxHNmDHjkUceGTBggMfjMQwjOWTbwyv2k6IVGwgEKioqursUAADwVeXl5RGRrusTJkx48MEHp06d6vF41PU8RKSGY0+GJlz3OikiFl8DAMApIdk8DQaDl1xyyS233DJlypRgMEgpt3xS18jiMlk6STqKT4YyAADAVxeNRolIhSulRG/q5TpI2ZMiYgEA4BR13ExFuCqIWAAA+KqOaq0qqUOwCNdUiFgAAABX9PSLlgAAAFyCiAUAAHAFIhYAAMAViFgAAABXIGIBAABcgYgFAABwBSIWAADAFYhYAAAAVyBiAQAAXIGIBQAAcAUiFgAAwBWIWAAAAFcgYgEAAFyBiAUAAHAFIhYAAMAViFgAAABXIGIBAABcgYgFAABwBSIWAADAFYhYAAAAVyBiAQAAXIGIBQAAcAUiFgAAwBWIWAAAAFcgYgEAAFyBiAUAAHAFIhYAAMAViFgAAABXIGIBAABcgYgFAABwBSIWAADAFYhYAAAAVyBiAQAAXIGIBQAAcAUiFgAAwBX6l64hpSQixpj6AU4G6utgjHV3QQAA4HMhOOHUpk41cBifJHDyB5Dqy+umZCvWsqy6ujohHClQnXULqelGIBAoLCxERQZw0krt+cPJX7djjHVjhfk1Ooqrq6sHDhzofpHgi0ydOnXJkiW6riNiFfU5RCIRy7I07cuPZ/jXY0RS2rYdCAS8Xi+OzOSvryr37i0MKN31RXx5lZRyuEjDMK668WfZhWXCsTjXXC4bHOY4dkZW3pP3/KC4qEh9I/jTVSzL8ng8c5988tNVqziTtm1zzggthxOGMSmE1+eLm/acOXNmzZrlOI6u9+hznWSzJBaL7dixIxAIoC3bXaSUmZmZRUVFJ28rNsmxHcuyh0+YXjFkjG3bnGM28onjWFZBad7ce65PJOJECNfDHMchokULFy758MOSvoO5ZgjHIZx/nChSCsPQ45FI4749Y8eORcRSSsRWVlaOHz/ea+gJy+7uQvVQuq7PmTPnT3/60ykQsYwxIpmIRaORDgcRe2I5th0JZUkp1LfQ3cU5iag/G6/Xq/kzHn91VXHvzEiIcGyeMLZJhWW0ZP7Sn88+z+v1EvpXjuj5I4/XN/zMaZrHK4XDcFyeQFJI3aN/+sFbjmPTydxRfCTGNU3TdJKEiD2hJGm63nWU9PQq7FhCCMcy9+/ebsYropEOHJwnjG1Z0VB544Eax3GEEN1dnJOLmYiblrzp4aeL+pQ5Fs78TigpKTOHzs31qI6u7tKj+3PgtMKY4fV5fH7bNjFR4IThXPP4fLrhIbRfj8EZJ+HU1+yyLBs9fyeYJNGSkSeE6N42CSIWAMAVkiQxZni8Hp8fEXuCSSm8Pl+3j6zhKwcAcAXDmM5JoTu/BUQsAACAKxCxAAAArkDEAgAAuAIRCwAA4ApELAAAgCsQsQAAAK5AxAIAALgCEQsAAOAKRCwAAIArELEAAACuQMQCAAC4AhELAADgCkQsAACAKxCxAAAArkDEAgAAuAIRCwAA4ApELAAAgCsQsQAAAK5AxAIAALgCEQsAAOAKRCwAAIArELEAAACuQMQCAAC4AhELAADgCkQsAACAKxCxAAAArkDEAgAAuAIRCwAA4ApELAAAgCsQsQAAAK7Qu7sAX4mUkjEmpZRSkpTEOqnl3V066CmklMQYSfl5K+BoBIBUp0bEJtPU5w/qHq9tmYlY5J/OVyllcpvJ/xIRY2oxSyb64Vw/3gr/kl8NThXJL10dDZ0/dx1LxBhJ0Z3lg54qWVPR4QOSiBiRVC8xxinlAIYT6dSI2OQxtHfbxuaGfdn5xaV9BxP7ooMmmYtSSikFEeOcp6ajahBruqHpOmNcknRs27Et6qw9D6es4fFyTSMix7Yc28aR2jMlazFN0xnnQjhExBkTQjBiUgrGNeE4J+DYkFJKISRJRoxrWmoN2/lDV4ePWsIYx3nh6Sr129c0XTMMxphjW7ZlGYZXMzy2ZdqWqbr9uruwPdEpELFSSiGcQFpGfe3uPz98W/W2jRWDR9300J8LyysSsZgKzmPflVzo9Qc9Xp8QTjTUngxOlbBeXyASagu1NduWybmWlpkTzMi0LZszksRUc0VK2VRfF4+GGWPBzOxgehahtuqRVGxxTW9tavhs1YfhtibirN+QsSV9B61492UrHht25rS+Q8fIz+9G/op7YYxJIYQQRJJrGmM8dZtSCs61YGY213THtiKhds45pbSqpZSGx+v1+bmmSylsyzLjMSFstR0ct6eT1P42rmnxaKR930HHttOzc9MycpobD3S0NmXlFmRk5wkh6P8wkJEa5EpqP19yJSFF1zCKOq/j7MhOQcdxkp09XNN7wtF4CkQsY4wkca5ZiUQ8FiYi27KsRJxzTUqhzt1JNWm7TtuJ1DcnpZR7Ktc3Htjr9QcHjZrINZ0xklJyzj1+/+YVizasWNhQtzseCWm6p7hXv6mzrhk8ZlI01K7phm3ZwYysLas//MeLvw+1NUvhjDjrGxd8+4ZgeqZtWT3h4IBUUkqSgph8969PfvDq02phv+Hjv3Prg688+SARRSOhASPH25b1f9mLylfD6/MH0xnnkY421QRRrwohvP6gY9sbli8Md7SkZ+cPPWOKlYirnkGSkjHu8flaD9Xv37sjGmo3PJ6MnIKSigEeX8C2TBXGcNroGskiTdeaG/YvnPfH6u2bbTMxeMxZU2de8/E/Xl774dvjp8+6ZPbtHo/H+T90sRx+o5qOQFLVsYdH04TQDU9aMF3TDWIkhYzHwlYifmS+2mmZOYbHq7YUbm917NO/Ij0FIlZKyTQtFgkXlFZcdcPPdmz+tM+Q0YXlfRKxqOHxGYZhW5Ztm7ru0XSDSNqW6TgOETEiw+Nb8MLv1ix+w/D6nnj7s4y0zEQixhnXDWPN4rf++uuftjbVJ3e0Y9NK4mzSBTM6WpsZ54bHG49F33/l6U2fLFIrGP7gOTP/PSMr1zLN7vksoDuoWU5SSk3T66t3rlnyFuO8V/9hvQaOKCitIEnBjOx4NMw0PeWEXg1QiM6hW8Y41zpP+dU4hOrslVLVVowxxjljTAih6XpD7e49W9ebifjQcVOz8gqFkJxrROT1BQ7u2/vh359b8tqz8Vg4p7DsmaW1hw7U6oZHCME1jXN90yeLlr/90qZPFiXiUSLKL+l96Zz/PPfy6ywzLmXnbILu+iThX0sdZZqux2PRJX//y6JXnlLLm+prS/sN2b9n28G6PXu2ro9FOvyBEtuO/NOXkHQOQ3Du8XiFlETSjMfVGZt6yZeW3tHcuHnlB6G2FiLSdL3PkNF5Jb0ZdeWrbaVl5W5Y9l7zwTr1ZzJ68gVpWTlfMHnw9HAKRCypgXvhEONjpswYNmG61+t1hMMYD7U2tTUfzMkvzswt7Gg91NFyiHGeU1DiC6RZiYQQzr5dW9uaGjRNJ0l1u7ZmZOXmFJb4Ahn7dlf97yO3hztacovKx0ydkVNYEo9GDh2oGThqUjQU45xLIo8/8N5Lf9i6dmlmToEQTrij1eP1M8a6KknoKVhXGzGnsHjr2hWapkkhrv3Px87/9ozG/c7WtcstM+7YFknZtaIUwjE8Pl8gqGm6lNK2zHg07Di2pulEJITgnHuDaYbHqzpjzERCzeCzLau4d+nSN1987rE7iOjuJ//ef/gZ0VBHLBqWUq758O0Fzz2xt2oDEWm6YVsJxkkNe2iaTiQ/XfLmy7+7r6XxgNcfLO49gDGqr929bePKaZfPVgGPhuxpQ7Vf1RBrc0PdltUfck3LL60YNfH8nMLivMJSRsQ4Nzw+rqbBS9Z14ud0BhtTM1SO6M4VwpFCnfkRY4xxjXNOUjKudbQcWr3o9Uiovbj3gLNnXt3R2u7xeIlzkrJy9dJlC15c9f584TiqeP2Hj7vxoacLSyvi0bCUzPB4G2p2/enBmzpaGtUKtz76wpizZwj7/9Trc/I7BSKWMSYcx/B4Y9HQgud+++mHb42fdsnF1/7YH8xY8e68NYvfmnbp93KLylcveePQ/hoiWdSr/ze+dX3FoBE7N6+Z/8eHD+zd4Ti2kPLVP/xCN7yXfO/WEROnL57/bLijJT0r76Lv3nzBt3+UmZsdj5qRUJtwnPbmVq5pPl9g95a177/0RzthnnXht2p3VoY++5SkQBugB1Ln6bZjr/3w3bUfLYhGOohoV+Xa+sd3DRo7mYi6BiaISNViIpie1VRft+njhZFQh6Zp2fnF/YePD6ZnRTpauaZ7vD4zHt9bueFQfW003O7x+QtKK3oNGM65ZnNr88pPKtd86PEFhGNv+XRpW1NDVl5h36FjNd148f/d4/H6Zt/12POP3+3YFqkTPiIiqRl6ddWml564t62poffAEWdfem1xr36MaN/e7aV9BgrbIkmMYxrB6YMxpkbKghnZwfRs2zKF4wwYeeZjL/9hXzVtWb06EY9KIdQ6jDFGUgjH4/UH0jI03SAix7aj4XYzEU+dChpMz/L4/KrXxLYS0XCHbZrEWFZuYTTcNm/uA0Q0dNzZP7z3P6rWMysRNwzP1vUfP/vwjw8dqPYF04eMnZyRnd/cUBcOtSWiEa7pUhCRIxz+8u8fCLU2+dMyLDNBUsbjESZP/0PxFIjYzs4Qw4hFI3urNh3aV71n60YzHvMF0vZu21S9fdP7r8Qiobb25s6To+0bVh6s2/uT3/zNTMQq1yzt3Ihwdn+2lojOuvBbiVhkx6bVjLHSvoMu+LcbuKa1NjZphq7phnAcKR3OeSIeW7Xo9cb9e8dMmTHx/Cv27dlGRIzx5CAE9BDqtJ9pmmOZr/z+wZ2bP1XLX/rtz4lozn/9tmLIyGRoqUrK60/7+L1XVy18beu6FfFIiIgKyvoMn3DueVd9v6zPUNs2D9btXfL6/25ds3T/3u2OYzPOS/oMmjzj6nNmXmP4fC/+5mfJ4/ad558gogGjJ97y0J+DmTnTLv3euOmzisv7PvfYXWp/ateca1Y8UbV2eVtTgz8tY+rM71425w4zHmVcGz5xup2Im4kE66pGT/QnCO6QUqoukHXL/rFh2XsdrU1EVLtjy2/ueiQ7v7xi0Gg1xYnUtdwkHSnSM3Prq3duXbM01N5CRIH0zOFnTivu3T8Ri0opNN3j2NZnq5bs21OViEVJyuz8kmFnTssuKIpHI5+tWvzp4jd8gTTLTITamv9w3+Mk9TPPvyIRjy5784VDB6ozcvIvuPpH06+4zuMNtDbVJxLx3MLSeDRCJA2vb9PHi7asXiqlHH7mtA0rFtqWqWmaZKf/0XgKROzhu0wQM7xexrnHpzpsmcfr55wfqN6RXVAy67qfBDKyly/4a33Nrm3rV1Rv29xnyOjv/eeji+c/e2Dvdk3TL7/+p75AcMTE6c0N+2ORDlXXrFny1q7P1qhd9Bk2dti4sw2vz+vzb/l06acfvJmVV3jRNTfll/SKhTuoq2cmef0ZWgM9AWNMMkZSappWUFpxoGZnNNQuhcgpLOOc+9PSiKjrWllijGmasX7Ze889ekeko83w+gtK+0TDHY379i7Zt7e5vu6H9/4uK794+6ZV7730P0SUnp1nGN5we8v+3VWvP/XLwvK+46ZdklNU7k/LjIXbiSgzt8AwvLkFZVzTGGOX/uBOzni4vfmIIkpiXIuFO+r2bGOMFZb1HT5het2urR0tjR6vP7ug2OsLSNtimkY4aE8jUkpN14Qjly3428p/vKIW1u747PnHPxs+YdptvxFjplIAABckSURBVP6bmnknmSQphRC6bqx456Xlb7+05dMPkxsZMm7quZdeO3rKDE3Xwx1t8//40MYVC9uaDqpXGeOjp8y48saflvUduvClP65aNF9VxXW7Kv/3l3f5gunDJ50XajlUu7OScT58wrlX3vgzrz8Qi4TTsrIT8aiVSAhhE5FtW4vnPxvpaL3omltyi8o2rHhPlZ/1gObKKRCxyuEpwkJIqSagkyQphPAF0i6dc8eF374xIzvQ0dJYX7OLa0a4vdnj9V/xo7u2bVh5YO92TTdmfv+23MLc1kPtOzetthJxItpbtXHuT2cnd5GVWzjt8uuu+NHd7a3N7/3tD80NdRf8241Dx5+zc/OnrGtgXw25EfqLe4zkGBXXjMuuvzu3uPyDV5+Jhtq/ffPPC0r75JdVtBzc33nWRcQ4D7Udmjf3/khHW0FZxcXX3FrWf0h7a/Pyt17YvGrxjk2rN36y6Lwr5hSWVcyc/ZPSvoPK+g1Jz8qt3bHl9ad/tbdqQ93OLWOmXPidW3+uadrH78yzrMQ3//3WfsPG+oPpvkCaFMKMRYkkO2Y8lTEWj0VaG+ullPFoaOmbLxzYuz0ei3BNyyks/cZVPxg4YkKko5XrBlL2dCKEI0lO/MZlZjRatX55NNReWN5vzNQZZX0HRUNtmq4TEZPMduy0zKylb774/GN3RUJteUXlwyZME47z8XuvVq1dXrdra35Jr77DxzftqvzojeczsvPGnvPNYHpWuKP1s5WLNyx/Vwj7rt++esa0bwphr1/2D9sy84p7jTt3puHxpKVn7flsbVN9rRRiwIjx9bW71320QNP0vOLeQ8dP1TQ9Fg1n5Re9+fRjW9cuqxg86tI5dyx760VhO9RjqtBTJmLp8y9+9fmDpX0HR8MdjmMH0jK5ZthmPNLeZpvmgepdsUiIiIQUDTW7YuGw7jE0TVOTPoQUE86/fPiZ0+prdi1964W25oNL3/rr+Okza3d8tunj94dNmHbpnDvzijMa6vIMj4+IDK8vp6BE93gT8YjEpdw9Buu6rVe/YWPrdm3VDS8RDRg1sc+Qke0tzc0N+zpn6kpijNXu3Fpfs5Nr2ohJ08//9vVCiEBaRiCQtmHFwoSM7q3aJITdd+jY/sPPrN6+YduGj2PhULijNRJqI2KJWDQRi1QMGlhSMYBpGlnUZ/Co0ZMviEVDiViUSBIjTdPVXS9SykeMMek4tpUgooba3f948cnU1xv3VV9/7+9K+wyKhNrUIBycBtT1XZLkqEnfCGbk1O7aEg219x4w4kf3P9Fc39B8cF9ybp2mGWYi9sl7r0RCbcUVA6780c9GTT7fsa2y/kPfee63Ha2HPv1wQa/BI3MLS256+M/FvfqV9x8WTMtsb2t66oGb1n749p7KdZFQ28QLrigs67t55WLbMkv7DLrhgSfqdu5Mz8rtaGtOxCLE2PIFL3305gs12zdzrmcXFE8477KZ192WW1i4bePqf7z0P45tz7jmZt3jtcyEmj/gOLbj2MmRi9O1Oj11IvZ41NcjpDTjcca5phtCOExKIopFQpKkx+tTNw8jIt0wDI+3c3IIERH1GTLmBz/7XX5JWcuhhlik/aM3XiAp9lZtrNtVqRtGLNTx6v88yLkWam85uG8PEe3bs/XZX95++Q/vKurVLxYNa5rWPb82nECHJ1syGQm1x8IdqhMl3NHa0dKkLuxTlYPqVmmqr1H/y8gqcIToaG4kovyy3tn5xa2H6s1Y2OPxVW/bvOjVZ6rWLmvcX526Lykl4zwaduLRqDpEY+GOjtZDjm2ryZ9Ex7nGQQ1eMMaYphFRID1r/PSZQ8edHQt3rHh33q7P1u7ctGrLqg97DxqppjWcrnVZT8O67izGOPd4fZ2j8hr3+nQ1D46YJCIpnEB6ZvXWzY379jLGzjj7m+PPm+XYNkl5+Q/uWvrG86G2pq1rlprf/0luUdmYKRduXbt89QdvRDvaJFF9zU4hHN3wmmbCT8zweDtPNzn3+nTNMKQUyfn2e7au55qemVsQCbU3N9S9++Lc7ILii/79pnefn9vRcuisGVePP3dmRk6+1x9gjCRRIC3TH8yIhdu69VN03akdscnKgqXcH0xNUuOaRoxJkobH07km48KxNV03vD7D6ycij8erGfq+Pdu9/kBRr/6qguOcR8PttmXu2bp+z9b1qbtr2l/TtL9m4gWXVwwZHY2ETuivCt3k8LXzkmmarsZESd2sTjcc53CDUjJikknhSCkZkXAcKYSmaYyR4zhmPEZEmu4RUq798O2lbz5PRL0GDB805qxIR+v2jSubG/YxzqWUnaduybN7rhFzqGuUhDh1TmPpvDpIqNvlSCLOOBEVlvW5/Id39Ro4nIRknNXu2GKZiYSZsMwE45rEMMfpInm21HmlTdccEeGIroO2czXd42ltauhobZZS+tPS1e0VHcu0bSuvqPxA9Y5YJKRx3lCz+8+P3FazfVOk44jYE8LhnHcebF27dhwhxRE35Z54wZUzvvMfwrFrdmx5969zDx2o2bL6w9yisurtmxhjusez7M0XiPOqdR+rN6798G2v199/xPhkL9GJ+NROuFMmYr9gJmQyXjuv4U8ZQudcS8/KYYxL4SRiUX9ZmpWwMnIL07NyWw7ur9tdVblm2bmXXV356er1y97jmubxBvJLK3oPGj5w9CTD8AghvF7/oQPVi1//30P7a3oPGjnt0u/1HTo20t6C6wt7iMN//19WAzBJkmR6dr6uexzHCre3aJrGuKbpRmvjgUiozeMLZBeVhtpa6qt3EmMjJ573nVt/kVdSbluJpx68WUUsY9x2nGBGpm4YViLm8Qc0TScp1K15JFMngV3HHiPOOTFORF6vP5CWwRgzE7FQW3NH8yFJ5PEGHMdWTQ3GePIpVe5+ZHBCJOeHqy83eaAyzlNDSwUv55xrqgGqcc6F4zjCMTwe04wTkW4Ymm6s/uDvW9csJaIh486eMuNqyeiTd1/Zum4ZY0xSZ5wnL3uVwpbqNt1c3U1PDhw98awZ5+3f09h70KjPVi05dKDGse2DdbvNeExKWv3BG6ven09SOraj+oFWvveaGYv2G36GuiHG6XpYniIRK7v66zjXDQ/nWmeXF9d0w6OGHGTXxdSabkgp1HMmNE1Lz8qVUkjJ//zQrf60jMkXXX32rGsmXXDl3q3r25saXnri3uVvv9hUX7u3aiMRDRk3ddCoCVJS36FnMMYdx/YH03ZXrlu79N3WxvrcwrJJF34rPTMnEmrj6CXueY4+z5NHLWGMsd4Dhhs+v4jaG1csXPHuvOFnnrt51ZLX/vgw1zSP19tvyGjHsbimc86jkY5EPBKPRhbO+8OerRuISArBOLPMRG5xuT+YHo+EqtatKCzvY1tWVl4h51oiGrZt27G6bi4mqL35ULi92fB4/Wnp5f2Hrlv6TlN93Udv/vWyH9zZeKD643+8IhzbH8woKu+j6boQQu96bMCJ+sygm3HOzUQ8r7g8I7eovaVp5+ZP22d8q6Csj7DtHZtXH9y3lzE+cORESWx/9Q7GmC+Qfu1/Pjps/MSOlvbtGz6hrnaLFEI3jIzcgkP7qznnvqDHE0iXkoKZOenZuaHWpsbaPYfq2zXdaDlQo2pIj8+XnV+Snp0fCbWreCeNMedw21f3eE/7qyBPjYiVTAopNd2wEnH1JDtNNzjnZjRiW2Y41EqMcc7UXe7i0RARccY514SUZ0y7eOvaFXsq1+6uXEdEUy7+jhTi7JnfbT1Uv3rRG/U1O+trdhJRXnGvCedfMeM7NwjhJGIxMx4lIsexzVgsEYtFQ+1qR5GOVnXzWFRSPYqUUna1GzTdUDOeZNdTJXTDIxxbSCEcmVNcPuv7t78894Hmg/te+u19ecXlodaWg/t2E9GUi78zcNRErz/Ya/CIle+/tqdy/R/uv8HvT6vevomI1DYZY4lYpGLQKHV7xaVv/XXzJ4tyisq+95+PpmflPvur21sPHSQpdcNDRGYi9vANlxBjF/7bf0y+6Fujp1y44r1XmvbXrFo4f0/lukQ8cmDvDiK66Jqbhk04Nxpq0zSN4dLY007XF9o5IyDl+1UjGlos3NF78Kjy/kNrt2/eumbpi0/cO2TsFMexVrz7Sri9RZIcf94sry/g86dxTbMtc/mCv1WtW16zbfPGFQup81YATAhheLy5RWXN9XUNtbuf/u8HAunpEy+4sqzP4MLyfpGO1rXL3uWGUVBaUbl6Sd3OSuE4Q86YMm76zIrBoywzoQZBdN1YvuBv7730P8Jxrr7l/onnX865hojtfoxx20z4A8GrbvxZ82WzcwpLfIE0IcQl1/544vmX+wLB0j6DbMeWkY4J37isvN9Q6di9Bo8kRtJxevUf9oN7nmiur7Nt0xdI6z1oVDwa9foCs77/k3HTZ4Zam6V0ONeycgoKevULpGUkohHdMNRhqjFDCCevsHT23Y+HWpqz84vTMrJt2yRcF9vDMMaYJOEIry/Y3twoHFsKwRiXQuqGJxpqI6L0zBwpHCmc6Vd8P7+k9wevPr1t/SdtTQ1E1G/4uCkXf3fCeTM1w+PY9qQLroqG2t978cmDtbuJaNql10YjHZ9+8IYZjxken2NZGdm5377lgVd+/2BL44H25oPlA4b5/AFGrHLNskQ0kiyVbZnqVhjnzPp3x7ZK+w7+jwf/uHDenz794I29Va1EVDFkzPnfun7s2TM0Tbctk6MJe5pSN7vmnY9TPLxENzySSDiOsO1vfveWfbuqarZv+vSDNz5buVgIJxGLEtFlP7ir//Dxjm2edeGVi197xiF74bw/Gh5vPBom9cSczsFXO5CW2WvA8G3rVjQ37Hv9qUdKKgb2G3ZG/xHjzjh7xq7Nq5sO1Cx6+U+GxxsNdxDRlIu/M/ni7xgeX1n/IbpmCCmklJru2bL6Q8404rKgrKKgtCLa0Y6I7X5qerqm6/2GnTFg5AQhbNs0pRQVg0f2GzZWSmmZcSGEI+yC0oqSioGMyLISjm2r766s7+BeA4YzIklS3bvYsS2vPzBg+HjG1f07pRTStk0zHlMXk9Hhp4MJw+sfMmayehqobSWkECmTq6BH6LzZejQ89IwpD7+43HHsvKLyRCwqhcgrLn/4xeWSZFZukWUlGGO64Rl/7swBIydGQm0kHOI8EMzMyMllxG3blETp2bkzr7t9yje/bZsW17TsgmLbMi/9/h3BjCzHtqSUwnHGn3dp/xHj47Ew51pmboHh8UkpfvH8R7aZIJKOIxhjJCXXNMZ5Zm5hPBphjPcbNm72nf2v+OFdQggiFsjIyszOlyQc2+Kapp6QgpQ9bSQbrB6vN5ie2SicvOJy2yQppeH1BtIybcvMzCnIzCmIhFqLKwbc/NAzHy989ZN3Xzl0oNrrTxs56byzvvntsWd/U+O6mYj1Gz7u9t/Me/+l31euWa4bnrMu/FbF4JGv/vFhw+c3fH7Htjw+/zeu/H64rXndsveYsPsNH1tU1i8aCp131Q/zSnovfu3ZPVUbouGOsn5DL/i3H40/d5bPn5aIRVhXOaUUmqb7g+m6x5OIO16vPxYOSyaTjwro1s/SLadMxBKRlNIyE0SJ5ELLTFgp/6XOp6Zbx3tXnDofAatGFphwHNOJHXVDxOSzI46YLyCFmYgfVRjoaRhjUgpfMFiRN5JxHg21C+EQI8Pw9Bt2BjGWiEUsM6FOBy0zkZ1fVFDaizEupbBN0zTjwjHVzEzpOIbhKe83VD3SNRGLsmB6flF5IhEz47HkVRDFvftrukFSJuJRy0wQUVnfwVxTf7MyeTyTlLFo2LEt9ZiptMzsnIISxjlJaVkJMx5L3v3/NK7Ieib1bdqWmVdcftvjL1pWwh/MaG5s5JxnZOdfe+fjV998XyAtgziTQjq2VVjed+a1t5132WzbthljHn8gLSPbcSzHtjnXHMsaPfn8fsPOSMQiXOP+YIbX4zvj3JkaV0/QZkI4+SUV1975+JU33kOMAsEM3euxTdPw+s48b9bQsVMTiZgUju71ZuUUSCmsRKLzYcad5dWI6IxzLxkybipJmZaV4zgWZzw5l+q0dGpE7HGrBnnMf9nxlnQNPqkXO0M3ZS2W+mNyht7hSzWO992jquppug4G7th2uL2FiJLj8UKIUFtz6hK1shmLJKLhw+9nTA1HdZ0L2pFQW+eT7jgnKc1YVK2j3iGliIY7Om8lxpm6vDv5lqOL17Vr1aNjJmIkU/abMvUUh+7pJPmla7qRU1iqaZplJtRt/TVNy8orMIxyy4ybibha00rENN3IKSplXCMpHduyzETXhHOmDp6MrFw9v0hK9VRQu6i8r5QyHg2ro0bNAE3PyiEi2zItM6HpumOZwuHpOblZms4YcxzbTMSl47CUpwuoAkspff5gRlYuYyweiwjH6TxRPH2dGhH7uRdOHbPkuNXH16hTulZM3eOxb0cl1dOknnKxrsnkhy+ZSFlyuE455ihJvtr5LpYyKb1r5dSb3aRuQC1Xzz/5vBJ2vZEftePUOg6H7unk8JmTEPFomKjzqi613IxFE7GIujdF5xsYOY5tR7r6+ajzKh9KOTjNeFT12anKTw2s8sNnfuocLq5WUO9V545mLCpTN8uP2GznHhlzbCtqmZRyhJ/ex+SpEbEA3eu4dcHnnXt9XpXxVSqUL37vP/HGr/JeOEUlW7GpJ2SHz6iOOW/rvMD7yOPh6B6OI19O7iLlv4fXOGL5kW88bsfJcYt6evesIGIBAE5hX/HM70vf/k+cpX2Vt6Suc9yinsb5Suq2GgAAAPAvh4gFAABwBSIWAADAFYhYAAAAVyBiAQAAXIGIBQAAcAUiFgAAwBWIWAAAAFcgYgEAAFyBiAUAAHAFIhYAAMAViFgAAABXIGIBAABcgYgFAABwBSIWAADAFYhYAAAAVyBiAQAAXIGIBQAAcAUiFgAAwBWIWAAAAFcgYgEAAFyBiAUAAHAFIhYAAMAViFgAAABXIGIBAABcgYgFAABwBSIWAADAFYhYAAAAVyBiAQAAXIGIBQAAcAUiFgAAwBWIWAAAAFcgYgEAAFyBiAUAAHAFIhYAAMAViFgAAABXIGIBAABcgYgFAABwBSIWAADAFYhYAAAAVyBiAQAAXKF/zfVlKldKBMdz5GeOTx4A4BTwNSJWSknEDI/X6/M7ts05WsAnjm3bXj9jjBEREevm0pycJM7/ugE+cIAv8DUiljFGJBsP1Oq+gLBthog9gYRjx6Jh27aFEKjRjkNKYoxzjWsa5xrnWncXqKfo+sxRG3wOnPl1k5PkM//yiFVFZIzphoeIfnf3ta4XCj4HY8zr8zNGjDEhRFejFohxzhhJ4QjHlsIR6Es/UYT6zCWOxuOQUhJjhsfr8focDT1/J5SUwuP1M8a6N2W/PGKTfzlpaWmzZ88uLStzHIcRQ2/liSSlZIybifioUaPUQYMaTVF/P5FoVJqxN59/MpCRaSfihLrsRBGOE0jP2rerUkqZSCSo6xsBIuKcc87amho03eM4Duf4mz1xpJTxSJgxxjlXx2S3VJtfI2ILCgr+8pe/uFwe+HLJfoXuLshJQbUMRo4cGQqFmratsG2biGFG2InDGAnh9flHjx7dq1cvwpGZ+hfKuHDMJ376Q0GMcFp8YkkpuaY5thWNRlW3X7f0InyNjmIppWVZOEq6F2NM13XqpjOyk5DH4yGiJ598srsLAp0Mw+juInSz5B9mZlbWpEmTNI1bltW9ReqhJPEBvUaOHKlqy26pM7u5nxq+luSBQmgrdFGfiWVZQojuLktPp2marus4+YOTTTdG7Ne9Lha6kzo+UH8dS7XsAU4GyZNgIYRpmt1dnJ5O0zTDMLrrzA+tWAAAOA0d1e2HjmIAAIDTB65tAAAAcAUiFgAAwBWIWAAAAFcgYgEAAFyBiAUAAHAFIhYAAMAViFgAAABX/H+BcydNpkA0RQAAAABJRU5ErkJggg=="
    }
   },
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* If necessary (and possible) `numpy` will **upcast** to\n",
    "  make all values in the array have the same type\n",
    "  ![Screenshot%201-13-22%20at%2016.11.22.png](attachment:Screenshot%201-13-22%20at%2016.11.22.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "np.array([3.14, 1, 5, 9, 2, 6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Arrays can be multidimensional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "np.array([range(i, i+4) for i in [2,5,7]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* There are many ways to create arrays from scratch, using\n",
    "  `numpy`'s builtin routines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Create a length-10 integer array filled with zeros\n",
    "np.zeros(10, dtype=int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Create a 3x5 floating-point array filled with ones\n",
    "np.ones((3, 5), dtype=float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Create a 3x5 array filled with 3.14\n",
    "np.full((3, 5), 3.14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Create an array filled with a linear sequence\n",
    "# Starting at 0, ending at 20, stepping by 2\n",
    "# (this is similar to the built-in range() function)\n",
    "np.arange(0, 21, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Create an array of five values evenly spaced between 0 and 1\n",
    "np.linspace(0, 1, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* There are many ways to create arrays from scratch, using\n",
    "  `numpy`'s builtin routines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Create a 3x4 array of uniformly distributed\n",
    "# random values between 0 and 1\n",
    "np.random.random((3, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Create a 3x4 array of normally distributed random values\n",
    "# with mean 0 and standard deviation 1\n",
    "np.random.normal(0, 1, (3, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Create a 2x5 array of random integers in the interval [0, 10)\n",
    "np.random.randint(0, 10, (2, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Create a 3x3 identity matrix\n",
    "np.eye(3, dtype=int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "`numpy` arrays are stored in contiguous blocks of memory. If you want to **add rows or columns to an existing array, the entire array needs to be copied to a new block of memory**, creating gaps for the new elements to be stored. This is **very inefficient if done repeatedly to build an array.**\n",
    "\n",
    "In the case of adding rows, your best bet is to create an array that is as big as your data set will eventually be, and then assign data to it row-by-row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Create an uninitialized array of three integers\n",
    "# The values will be whatever happens to already exist at that memory location\n",
    "np.empty(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Warning:** two arrays may share the same memory. This means you have to be sure that when you modify one object, you aren't inadvertently modifying another."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = np.array([1, 2, 3, 4])\n",
    "y = x\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x[0] = 9\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "There are ways of checking for and preventing these kinds of mistakes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## `NumPy` Standard Data Types\n",
    "\n",
    "`NumPy` arrays contain values of a single type, so it is important to have detailed knowledge of those types and their limitations.\n",
    "Because `NumPy` is built in `C`, the types will be familiar to users of `C`, `Fortran`, and other related languages.\n",
    "\n",
    "The standard `NumPy` data types are listed in the following table.\n",
    "Note that when constructing an array, they can be specified using a string:\n",
    "\n",
    "```python\n",
    "np.zeros(10, dtype='int16')\n",
    "```\n",
    "\n",
    "Or using the associated NumPy object:\n",
    "\n",
    "```python\n",
    "np.zeros(10, dtype=np.int16)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "| Data type\t    | Description |\n",
    "|---------------|-------------|\n",
    "| ``bool_``     | Boolean (True or False) stored as a byte |\n",
    "| ``int_``      | Default integer type (same as C ``long``; normally either ``int64`` or ``int32``)| \n",
    "| ``intc``      | Identical to C ``int`` (normally ``int32`` or ``int64``)| \n",
    "| ``intp``      | Integer used for indexing (same as C ``ssize_t``; normally either ``int32`` or ``int64``)| \n",
    "| ``int8``      | Byte (-128 to 127)| \n",
    "| ``int16``     | Integer (-32768 to 32767)|\n",
    "| ``int32``     | Integer (-2147483648 to 2147483647)|\n",
    "| ``int64``     | Integer (-9223372036854775808 to 9223372036854775807)| \n",
    "| ``uint8``     | Unsigned integer (0 to 255)| \n",
    "| ``uint16``    | Unsigned integer (0 to 65535)| \n",
    "| ``uint32``    | Unsigned integer (0 to 4294967295)| \n",
    "| ``uint64``    | Unsigned integer (0 to 18446744073709551615)| \n",
    "| ``float_``    | Shorthand for ``float64``.| \n",
    "| ``float16``   | Half precision float: sign bit, 5 bits exponent, 10 bits mantissa| \n",
    "| ``float32``   | Single precision float: sign bit, 8 bits exponent, 23 bits mantissa| \n",
    "| ``float64``   | Double precision float: sign bit, 11 bits exponent, 52 bits mantissa| \n",
    "| ``complex_``  | Shorthand for ``complex128``.| \n",
    "| ``complex64`` | Complex number, represented by two 32-bit floats| \n",
    "| ``complex128``| Complex number, represented by two 64-bit floats| "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## References"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### `python`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* **list comprehension** [[doc]](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions) allows the construction of new list from old ones\n",
    "without explicit `for` loops (or `if` statements)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# squares of odd numbers for x in {0,1,...,9}\n",
    "[x**2 for x in range(10) if x % 2 == 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `sum`: [[doc]](https://docs.python.org/3/library/functions.html#sum) computes the sum of a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `str`: [[doc]](https://docs.python.org/3/library/stdtypes.html#str) converts an object to a string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### `sys`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `getsizeof`: [[doc]](https://docs.python.org/2/library/sys.html#sys.getsizeof)\n",
    "determines the size (in bytes) of an object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `numpy`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `np.array`: [[doc]](https://numpy.org/doc/stable/user/basics.creation.html)\n",
    "  constructs a `numpy` multidimensional array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `dtype`: [[doc]](https://numpy.org/doc/stable/reference/arrays.dtypes.html)\n",
    "  the common type of the entries of a `numpy` array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `np.zeros`: [[doc]](https://numpy.org/doc/stable/reference/generated/numpy.zeros.html) fills an array with $0$ values of the specified type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `np.ones`: [[doc]](https://numpy.org/doc/stable/reference/generated/numpy.ones.html) fills an array with $1$ values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `np.full`: [[doc]](https://numpy.org/doc/stable/reference/generated/numpy.full.html) fills an array with the given value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `np.eye`: [[doc]](https://numpy.org/doc/stable/reference/generated/numpy.eye.html) creates the identity matrix of the given shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `np.empty`: [[doc]](https://numpy.org/doc/stable/reference/generated/numpy.empty.html) creates an array w/o setting the values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `numpy`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `np.arange`: [[doc]](https://numpy.org/doc/stable/reference/generated/numpy.arange.html) constructs a range as `numpy` array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `np.linspace`: [[doc]](https://numpy.org/doc/stable/reference/generated/numpy.linspace.html) constructs an array of equally spaced values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "###  `numpy.random`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `random`: [[doc]](https://numpy.org/doc/stable/reference/random/generated/numpy.random.random.html) fills an array with random numbers between $0$ and $1$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `normal`: [[doc]](https://numpy.org/doc/stable/reference/random/generated/numpy.random.normal.html) draws random values from a normal distribution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `randint`: [[doc]](https://numpy.org/doc/stable/reference/random/generated/numpy.random.randint.html) fills an array with random integers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* (Note: this subpackage has been updated and future versions should access the random number generators in a different way ...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# `numpy` arrays: Attributes, Indexing, Reshaping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* `numpy` arrays improve on `python` lists in many ways.\n",
    "* `numpy` arrays are **homogeneous** **multi-dimensional** collections of data.\n",
    "* As such, a `numpy` array has:\n",
    "    * a **shape**, specifying its size in each dimension;\n",
    "    * a common **data type** for all its elements.\n",
    "* These (and related) **attributes** of an array can be directly accessed.\n",
    "* Basic manipulation of the data in an array involves **indexing** to access single elements\n",
    "  and **slicing** to access subarrays.\n",
    "* `numpy` extends `python`s set of indexing and slicing operators.\n",
    "* The **shape** of a `numpy` array can be **modified**, without affecting the data it contains.\n",
    "* Multiple arrays can be **combined** into one.\n",
    "* Conversely, and array can be **split** into multiple parts.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* a `numpy` array is a **multi-dimensional** **homogeneous** collection of data.\n",
    "* in **mathematics** and **physics**, such an object is often called a **tensor**.\n",
    "* a `numpy` array has a **shape** and a **dtype**.\n",
    "* let's investigate these in some simple examples.\n",
    "* start with three random arrays, a one-dimensional, two-dimensional, and three-dimensional array.\n",
    "* `np.random.randint` constructs such random arrays of integers in a given range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x0 = np.random.randint(10) # A single random integer\n",
    "x0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x1 = np.random.randint(10, size=4)  # One-dimensional array; size means shape\n",
    "x1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "x2 = np.random.randint(10, size=(3, 4))  # Two-dimensional array: shape 3 x 4\n",
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x3 = np.random.randint(10, size=(2, 3, 4))  # Three-dimensional: shape 2 x 3 x 4\n",
    "x3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(x3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Each array has the attributes \n",
    "* `dtype`: the **data type** of the array.\n",
    "* `shape`: the **size in each dimension**, and"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(\"x2 dtype:\", x2.dtype)\n",
    "print(\"x2 shape:\", x2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(\"x3 dtype:\", x3.dtype)\n",
    "print(\"x3 shape:\", x3.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Further attributes of interest are\n",
    "* `ndim`: the **number of dimensions**, and\n",
    "* `size`: the **total number** of elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(\"x3 ndim: \", x3.ndim)\n",
    "print(\"x3 size: \", x3.size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Obviously, `size` is the product of the numbers in the list `shape`, and `ndim` is the length of that list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "len(x3.shape) == x3.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# from math import prod (available from python 3.8)\n",
    "x3.size == np.prod(x3.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##  Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\n",
    "1.  Construct a `numpy` $3 \\times 3 \\times 3$ array of $1$s (of type `int`).\n",
    "\n",
    "2. Construct a `numpy` $3 \\times 4 \\times 5$ array of random integers\n",
    "   in the range $1$ to $99$ (inclusive).\n",
    "   \n",
    "3. Create an array of $21$ values, evenly spaced between $0$ and $100$.\n",
    "\n",
    "4. Create an array with a sequence of integers,\n",
    "   starting at $1950$, ending at $2015$, stepping by $5$.\n",
    "   \n",
    "5. Create a list of all odd squares between $0$ and $10000$.\n",
    "\n",
    "6. Make a few `numpy` arrays, with random entries or ranges of integers, of varying dimensions.\n",
    "\n",
    "7. Determine the basic attributes of these arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "A=np.ones((3,3,3), dtype=np.int_)\n",
    "print(A)\n",
    "print('A.dtype:',A.dtype)\n",
    "print('A.shape:',A.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "B=np.random.randint(1, 100, (3, 4,5))\n",
    "print(B)\n",
    "print('B.dtype:',B.dtype)\n",
    "print('B.shape:',B.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C=np.linspace(1, 100, 21)\n",
    "print(C)\n",
    "print('C.dtype:',C.dtype)\n",
    "print('C.shape:',C.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D=np.arange(1950, 2016, 5)\n",
    "print(D)\n",
    "print('D.dtype:',D.dtype)\n",
    "print('D.shape:',D.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[x**2 for x in range(100) if x%2==1]"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}